eisa: fix coding style for eisa bus code
Thadeu Lima de Souza Cascardo [Fri, 5 Mar 2010 21:42:48 +0000 (13:42 -0800)]
Signed-off-by: Thadeu Lima de Souza Cascardo <cascardo@holoscopio.com>
Cc: Kay Sievers <kay.sievers@vrfy.org>
Cc: Greg Kroah-Hartman <gregkh@suse.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

drivers/eisa/eisa-bus.c

index 66958b3..806c77b 100644 (file)
@@ -39,10 +39,10 @@ static unsigned int enable_dev_count;
 static int disable_dev[EISA_MAX_FORCED_DEV];
 static unsigned int disable_dev_count;
 
-static int is_forced_dev (int *forced_tab,
-                         int forced_count,
-                         struct eisa_root_device *root,
-                         struct eisa_device *edev)
+static int is_forced_dev(int *forced_tab,
+                        int forced_count,
+                        struct eisa_root_device *root,
+                        struct eisa_device *edev)
 {
        int i, x;
 
@@ -55,21 +55,21 @@ static int is_forced_dev (int *forced_tab,
        return 0;
 }
 
-static void __init eisa_name_device (struct eisa_device *edev)
+static void __init eisa_name_device(struct eisa_device *edev)
 {
 #ifdef CONFIG_EISA_NAMES
        int i;
        for (i = 0; i < EISA_INFOS; i++) {
-               if (!strcmp (edev->id.sig, eisa_table[i].id.sig)) {
-                       strlcpy (edev->pretty_name,
-                                eisa_table[i].name,
-                                sizeof(edev->pretty_name));
+               if (!strcmp(edev->id.sig, eisa_table[i].id.sig)) {
+                       strlcpy(edev->pretty_name,
+                               eisa_table[i].name,
+                               sizeof(edev->pretty_name));
                        return;
                }
        }
 
        /* No name was found */
-       sprintf (edev->pretty_name, "EISA device %.7s", edev->id.sig);
+       sprintf(edev->pretty_name, "EISA device %.7s", edev->id.sig);
 #endif
 }
 
@@ -91,7 +91,7 @@ static char __init *decode_eisa_sig(unsigned long addr)
                 */
                outb(0x80 + i, addr);
 #endif
-               sig[i] = inb (addr + i);
+               sig[i] = inb(addr + i);
 
                if (!i && (sig[0] & 0x80))
                        return NULL;
@@ -106,17 +106,17 @@ static char __init *decode_eisa_sig(unsigned long addr)
         return sig_str;
 }
 
-static int eisa_bus_match (struct device *dev, struct device_driver *drv)
+static int eisa_bus_match(struct device *dev, struct device_driver *drv)
 {
-       struct eisa_device *edev = to_eisa_device (dev);
-       struct eisa_driver *edrv = to_eisa_driver (drv);
+       struct eisa_device *edev = to_eisa_device(dev);
+       struct eisa_driver *edrv = to_eisa_driver(drv);
        const struct eisa_device_id *eids = edrv->id_table;
 
        if (!eids)
                return 0;
 
-       while (strlen (eids->sig)) {
-               if (!strcmp (eids->sig, edev->id.sig) &&
+       while (strlen(eids->sig)) {
+               if (!strcmp(eids->sig, edev->id.sig) &&
                    edev->state & EISA_CONFIG_ENABLED) {
                        edev->id.driver_data = eids->driver_data;
                        return 1;
@@ -141,61 +141,71 @@ struct bus_type eisa_bus_type = {
        .match = eisa_bus_match,
        .uevent = eisa_bus_uevent,
 };
+EXPORT_SYMBOL(eisa_bus_type);
 
-int eisa_driver_register (struct eisa_driver *edrv)
+int eisa_driver_register(struct eisa_driver *edrv)
 {
        edrv->driver.bus = &eisa_bus_type;
-       return driver_register (&edrv->driver);
+       return driver_register(&edrv->driver);
 }
+EXPORT_SYMBOL(eisa_driver_register);
 
-void eisa_driver_unregister (struct eisa_driver *edrv)
+void eisa_driver_unregister(struct eisa_driver *edrv)
 {
-       driver_unregister (&edrv->driver);
+       driver_unregister(&edrv->driver);
 }
+EXPORT_SYMBOL(eisa_driver_unregister);
 
-static ssize_t eisa_show_sig (struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t eisa_show_sig(struct device *dev, struct device_attribute *attr,
+                            char *buf)
 {
-        struct eisa_device *edev = to_eisa_device (dev);
-        return sprintf (buf,"%s\n", edev->id.sig);
+       struct eisa_device *edev = to_eisa_device(dev);
+       return sprintf(buf, "%s\n", edev->id.sig);
 }
 
 static DEVICE_ATTR(signature, S_IRUGO, eisa_show_sig, NULL);
 
-static ssize_t eisa_show_state (struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t eisa_show_state(struct device *dev,
+                              struct device_attribute *attr,
+                              char *buf)
 {
-        struct eisa_device *edev = to_eisa_device (dev);
-        return sprintf (buf,"%d\n", edev->state & EISA_CONFIG_ENABLED);
+       struct eisa_device *edev = to_eisa_device(dev);
+       return sprintf(buf, "%d\n", edev->state & EISA_CONFIG_ENABLED);
 }
 
 static DEVICE_ATTR(enabled, S_IRUGO, eisa_show_state, NULL);
 
-static ssize_t eisa_show_modalias (struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t eisa_show_modalias(struct device *dev,
+                                 struct device_attribute *attr,
+                                 char *buf)
 {
-        struct eisa_device *edev = to_eisa_device (dev);
-        return sprintf (buf, EISA_DEVICE_MODALIAS_FMT "\n", edev->id.sig);
+       struct eisa_device *edev = to_eisa_device(dev);
+       return sprintf(buf, EISA_DEVICE_MODALIAS_FMT "\n", edev->id.sig);
 }
 
 static DEVICE_ATTR(modalias, S_IRUGO, eisa_show_modalias, NULL);
 
-static int __init eisa_init_device (struct eisa_root_device *root,
-                                   struct eisa_device *edev,
-                                   int slot)
+static int __init eisa_init_device(struct eisa_root_device *root,
+                                  struct eisa_device *edev,
+                                  int slot)
 {
        char *sig;
-        unsigned long sig_addr;
+       unsigned long sig_addr;
        int i;
 
-       sig_addr = SLOT_ADDRESS (root, slot) + EISA_VENDOR_ID_OFFSET;
+       sig_addr = SLOT_ADDRESS(root, slot) + EISA_VENDOR_ID_OFFSET;
 
-       if (!(sig = decode_eisa_sig (sig_addr)))
+       sig = decode_eisa_sig(sig_addr);
+       if (!sig)
                return -1;      /* No EISA device here */
        
-       memcpy (edev->id.sig, sig, EISA_SIG_LEN);
+       memcpy(edev->id.sig, sig, EISA_SIG_LEN);
        edev->slot = slot;
-       edev->state = inb (SLOT_ADDRESS (root, slot) + EISA_CONFIG_OFFSET) & EISA_CONFIG_ENABLED;
-       edev->base_addr = SLOT_ADDRESS (root, slot);
+       edev->state = inb(SLOT_ADDRESS(root, slot) + EISA_CONFIG_OFFSET)
+                     & EISA_CONFIG_ENABLED;
+       edev->base_addr = SLOT_ADDRESS(root, slot);
        edev->dma_mask = root->dma_mask; /* Default DMA mask */
-       eisa_name_device (edev);
+       eisa_name_device(edev);
        edev->dev.parent = root->dev;
        edev->dev.bus = &eisa_bus_type;
        edev->dev.dma_mask = &edev->dma_mask;
@@ -210,42 +220,45 @@ static int __init eisa_init_device (struct eisa_root_device *root,
 #endif
        }
 
-       if (is_forced_dev (enable_dev, enable_dev_count, root, edev))
+       if (is_forced_dev(enable_dev, enable_dev_count, root, edev))
                edev->state = EISA_CONFIG_ENABLED | EISA_CONFIG_FORCED;
        
-       if (is_forced_dev (disable_dev, disable_dev_count, root, edev))
+       if (is_forced_dev(disable_dev, disable_dev_count, root, edev))
                edev->state = EISA_CONFIG_FORCED;
 
        return 0;
 }
 
-static int __init eisa_register_device (struct eisa_device *edev)
+static int __init eisa_register_device(struct eisa_device *edev)
 {
-       int rc = device_register (&edev->dev);
+       int rc = device_register(&edev->dev);
        if (rc)
                return rc;
 
-       rc = device_create_file (&edev->dev, &dev_attr_signature);
-       if (rc) goto err_devreg;
-       rc = device_create_file (&edev->dev, &dev_attr_enabled);
-       if (rc) goto err_sig;
-       rc = device_create_file (&edev->dev, &dev_attr_modalias);
-       if (rc) goto err_enab;
+       rc = device_create_file(&edev->dev, &dev_attr_signature);
+       if (rc)
+               goto err_devreg;
+       rc = device_create_file(&edev->dev, &dev_attr_enabled);
+       if (rc)
+               goto err_sig;
+       rc = device_create_file(&edev->dev, &dev_attr_modalias);
+       if (rc)
+               goto err_enab;
 
        return 0;
 
 err_enab:
-       device_remove_file (&edev->dev, &dev_attr_enabled);
+       device_remove_file(&edev->dev, &dev_attr_enabled);
 err_sig:
-       device_remove_file (&edev->dev, &dev_attr_signature);
+       device_remove_file(&edev->dev, &dev_attr_signature);
 err_devreg:
        device_unregister(&edev->dev);
        return rc;
 }
 
-static int __init eisa_request_resources (struct eisa_root_device *root,
-                                         struct eisa_device *edev,
-                                         int slot)
+static int __init eisa_request_resources(struct eisa_root_device *root,
+                                        struct eisa_device *edev,
+                                        int slot)
 {
        int i;
 
@@ -263,17 +276,19 @@ static int __init eisa_request_resources (struct eisa_root_device *root,
                
                if (slot) {
                        edev->res[i].name  = NULL;
-                       edev->res[i].start = SLOT_ADDRESS (root, slot) + (i * 0x400);
+                       edev->res[i].start = SLOT_ADDRESS(root, slot)
+                                            + (i * 0x400);
                        edev->res[i].end   = edev->res[i].start + 0xff;
                        edev->res[i].flags = IORESOURCE_IO;
                } else {
                        edev->res[i].name  = NULL;
-                       edev->res[i].start = SLOT_ADDRESS (root, slot) + EISA_VENDOR_ID_OFFSET;
+                       edev->res[i].start = SLOT_ADDRESS(root, slot)
+                                            + EISA_VENDOR_ID_OFFSET;
                        edev->res[i].end   = edev->res[i].start + 3;
                        edev->res[i].flags = IORESOURCE_BUSY;
                }
 
-               if (request_resource (root->res, &edev->res[i]))
+               if (request_resource(root->res, &edev->res[i]))
                        goto failed;
        }
 
@@ -281,99 +296,100 @@ static int __init eisa_request_resources (struct eisa_root_device *root,
        
  failed:
        while (--i >= 0)
-               release_resource (&edev->res[i]);
+               release_resource(&edev->res[i]);
 
        return -1;
 }
 
-static void __init eisa_release_resources (struct eisa_device *edev)
+static void __init eisa_release_resources(struct eisa_device *edev)
 {
        int i;
 
        for (i = 0; i < EISA_MAX_RESOURCES; i++)
                if (edev->res[i].start || edev->res[i].end)
-                       release_resource (&edev->res[i]);
+                       release_resource(&edev->res[i]);
 }
 
-static int __init eisa_probe (struct eisa_root_device *root)
+static int __init eisa_probe(struct eisa_root_device *root)
 {
         int i, c;
        struct eisa_device *edev;
 
-        printk (KERN_INFO "EISA: Probing bus %d at %s\n",
-               root->bus_nr, dev_name(root->dev));
+       printk(KERN_INFO "EISA: Probing bus %d at %s\n",
+              root->bus_nr, dev_name(root->dev));
 
        /* First try to get hold of slot 0. If there is no device
         * here, simply fail, unless root->force_probe is set. */
        
-       if (!(edev = kzalloc (sizeof (*edev), GFP_KERNEL))) {
-               printk (KERN_ERR "EISA: Couldn't allocate mainboard slot\n");
+       edev = kzalloc(sizeof(*edev), GFP_KERNEL);
+       if (!edev) {
+               printk(KERN_ERR "EISA: Couldn't allocate mainboard slot\n");
                return -ENOMEM;
        }
                
-       if (eisa_request_resources (root, edev, 0)) {
-               printk (KERN_WARNING \
-                       "EISA: Cannot allocate resource for mainboard\n");
-               kfree (edev);
+       if (eisa_request_resources(root, edev, 0)) {
+               printk(KERN_WARNING \
+                      "EISA: Cannot allocate resource for mainboard\n");
+               kfree(edev);
                if (!root->force_probe)
                        return -EBUSY;
                goto force_probe;
        }
 
-       if (eisa_init_device (root, edev, 0)) {
-               eisa_release_resources (edev);
-               kfree (edev);
+       if (eisa_init_device(root, edev, 0)) {
+               eisa_release_resources(edev);
+               kfree(edev);
                if (!root->force_probe)
                        return -ENODEV;
                goto force_probe;
        }
 
-       printk (KERN_INFO "EISA: Mainboard %s detected.\n", edev->id.sig);
+       printk(KERN_INFO "EISA: Mainboard %s detected.\n", edev->id.sig);
 
-       if (eisa_register_device (edev)) {
-               printk (KERN_ERR "EISA: Failed to register %s\n",
-                       edev->id.sig);
-               eisa_release_resources (edev);
-               kfree (edev);
+       if (eisa_register_device(edev)) {
+               printk(KERN_ERR "EISA: Failed to register %s\n",
+                      edev->id.sig);
+               eisa_release_resources(edev);
+               kfree(edev);
        }
        
  force_probe:
        
         for (c = 0, i = 1; i <= root->slots; i++) {
-               if (!(edev = kzalloc (sizeof (*edev), GFP_KERNEL))) {
-                       printk (KERN_ERR "EISA: Out of memory for slot %d\n",
-                               i);
+               edev = kzalloc(sizeof(*edev), GFP_KERNEL);
+               if (!edev) {
+                       printk(KERN_ERR "EISA: Out of memory for slot %d\n", i);
                        continue;
                }
 
-               if (eisa_request_resources (root, edev, i)) {
-                       printk (KERN_WARNING \
-                               "Cannot allocate resource for EISA slot %d\n",
-                               i);
-                       kfree (edev);
+               if (eisa_request_resources(root, edev, i)) {
+                       printk(KERN_WARNING \
+                              "Cannot allocate resource for EISA slot %d\n",
+                              i);
+                       kfree(edev);
                        continue;
                }
 
-                if (eisa_init_device (root, edev, i)) {
-                       eisa_release_resources (edev);
-                       kfree (edev);
+               if (eisa_init_device(root, edev, i)) {
+                       eisa_release_resources(edev);
+                       kfree(edev);
                        continue;
                }
                
-               printk (KERN_INFO "EISA: slot %d : %s detected",
-                       i, edev->id.sig);
+               printk(KERN_INFO "EISA: slot %d : %s detected",
+                      i, edev->id.sig);
                        
                switch (edev->state) {
                case EISA_CONFIG_ENABLED | EISA_CONFIG_FORCED:
-                       printk (" (forced enabled)");
+                       printk(" (forced enabled)");
                        break;
 
                case EISA_CONFIG_FORCED:
-                       printk (" (forced disabled)");
+                       printk(" (forced disabled)");
                        break;
 
                case 0:
-                       printk (" (disabled)");
+                       printk(" (disabled)");
                        break;
                }
                        
@@ -381,15 +397,15 @@ static int __init eisa_probe (struct eisa_root_device *root)
 
                c++;
 
-               if (eisa_register_device (edev)) {
-                       printk (KERN_ERR "EISA: Failed to register %s\n",
-                               edev->id.sig);
-                       eisa_release_resources (edev);
-                       kfree (edev);
+               if (eisa_register_device(edev)) {
+                       printk(KERN_ERR "EISA: Failed to register %s\n",
+                              edev->id.sig);
+                       eisa_release_resources(edev);
+                       kfree(edev);
                }
         }
 
-        printk (KERN_INFO "EISA: Detected %d card%s.\n", c, c == 1 ? "" : "s");
+       printk(KERN_INFO "EISA: Detected %d card%s.\n", c, c == 1 ? "" : "s");
 
        return 0;
 }
@@ -403,7 +419,7 @@ static struct resource eisa_root_res = {
 
 static int eisa_bus_count;
 
-int __init eisa_root_register (struct eisa_root_device *root)
+int __init eisa_root_register(struct eisa_root_device *root)
 {
        int err;
 
@@ -417,35 +433,35 @@ int __init eisa_root_register (struct eisa_root_device *root)
        root->eisa_root_res.end   = root->res->end;
        root->eisa_root_res.flags = IORESOURCE_BUSY;
 
-       if ((err = request_resource (&eisa_root_res, &root->eisa_root_res)))
+       err = request_resource(&eisa_root_res, &root->eisa_root_res);
+       if (err)
                return err;
        
        root->bus_nr = eisa_bus_count++;
 
-       if ((err = eisa_probe (root)))
-               release_resource (&root->eisa_root_res);
+       err = eisa_probe(root);
+       if (err)
+               release_resource(&root->eisa_root_res);
 
        return err;
 }
 
-static int __init eisa_init (void)
+static int __init eisa_init(void)
 {
        int r;
        
-       if ((r = bus_register (&eisa_bus_type)))
+       r = bus_register(&eisa_bus_type);
+       if (r)
                return r;
 
-       printk (KERN_INFO "EISA bus registered\n");
+       printk(KERN_INFO "EISA bus registered\n");
        return 0;
 }
 
 module_param_array(enable_dev, int, &enable_dev_count, 0444);
 module_param_array(disable_dev, int, &disable_dev_count, 0444);
 
-postcore_initcall (eisa_init);
+postcore_initcall(eisa_init);
 
 int EISA_bus;          /* for legacy drivers */
-EXPORT_SYMBOL (EISA_bus);
-EXPORT_SYMBOL (eisa_bus_type);
-EXPORT_SYMBOL (eisa_driver_register);
-EXPORT_SYMBOL (eisa_driver_unregister);
+EXPORT_SYMBOL(EISA_bus);