Few more u32 vs. pm_message_t fixes.
Signed-off-by: Pavel Machek <pavel@suse.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
        u32 device_state;
        MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
 
-       switch(state)
-       {
-               case 1: /* S1 */
-                       device_state=1; /* D1 */;
-                       break;
-               case 3: /* S3 */
-               case 4: /* S4 */
-                       device_state=3; /* D3 */;
-                       break;
-               default:
-                       return -EAGAIN /*FIXME*/;
-                       break;
-       }
+       device_state=pci_choose_state(pdev, state);
 
        printk(MYIOC_s_INFO_FMT
        "pci-suspend: pdev=0x%p, slot=%s, Entering operating state [D%d]\n",
 
 extern void mptscsih_remove(struct pci_dev *);
 extern void mptscsih_shutdown(struct pci_dev *);
 #ifdef CONFIG_PM
-extern int mptscsih_suspend(struct pci_dev *pdev, u32 state);
+extern int mptscsih_suspend(struct pci_dev *pdev, pm_message_t state);
 extern int mptscsih_resume(struct pci_dev *pdev);
 #endif
 extern int mptscsih_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset, int length, int func);
 
 }
 
 #ifdef CONFIG_PM
-static int skge_suspend(struct pci_dev *pdev, u32 state)
+static int skge_suspend(struct pci_dev *pdev, pm_message_t state)
 {
        struct skge_hw *hw  = pci_get_drvdata(pdev);
        int i, wol = 0;
        }
 
        pci_save_state(pdev);
-       pci_enable_wake(pdev, state, wol);
+       pci_enable_wake(pdev, pci_choose_state(pdev, state), wol);
        pci_disable_device(pdev);
        pci_set_power_state(pdev, pci_choose_state(pdev, state));
 
 
         */
        netif_carrier_off(tp->dev);
 
-       pci_enable_wake(tp->pdev, pci_choose_state(pdev, state), 1);
+       pci_enable_wake(tp->pdev, state, 1);
        pci_disable_device(pdev);
-       return pci_set_power_state(pdev, pci_choose_state(pdev, state));
+       return pci_set_power_state(pdev, state);
 }
 
 static int
                goto need_resume;
        }
 
-       if(typhoon_sleep(tp, state, tp->wol_events) < 0) {
+       if(typhoon_sleep(tp, pci_choose_state(pdev, state), tp->wol_events) < 0) {
                printk(KERN_ERR "%s: unable to put card to sleep\n", dev->name);
                goto need_resume;
        }
 
 static int suspend_iter(struct device *dev, void *data)
 {
        struct pcie_port_service_driver *service_driver;
-       u32 state = (u32)data;
+       pm_message_t state = * (pm_message_t *) data;
 
        if ((dev->bus == &pcie_port_bus_type) &&
            (dev->driver)) {
        return 0;
 }
 
-int pcie_port_device_suspend(struct pci_dev *dev, u32 state)
+int pcie_port_device_suspend(struct pci_dev *dev, pm_message_t state)
 {
-       device_for_each_child(&dev->dev, (void *)state, suspend_iter);
+       device_for_each_child(&dev->dev, &state, suspend_iter);
        return 0;
 }
 
 
        printk(KERN_DEBUG "state: %u\n", state);
 
        acquire_console_sem();
-       fb_set_suspend(info, state);
+       fb_set_suspend(info, pci_choose_state(dev, state));
        savage_disable_mmio(par);
        release_console_sem();
 
 
                                list_for_each(entry, &cs46xx_devs)
                                {
                                        card = list_entry(entry, struct cs_card, list);
-                                       cs46xx_suspend(card, 0);
+                                       cs46xx_suspend(card, PMSG_ON);
                                }
 
                        }
                        case PM_SUSPEND:
                                CS_DBGOUT(CS_PM, 2, printk(KERN_INFO
                                        "cs46xx: PM suspend request\n"));
-                               if(cs46xx_suspend(card, 0))
+                               if(cs46xx_suspend(card, PMSG_SUSPEND))
                                {
                                    CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
                                        "cs46xx: PM suspend request refused\n"));
        struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
        CS_DBGOUT(CS_PM | CS_FUNCTION, 2, 
                printk(KERN_INFO "cs46xx: cs46xx_suspend_tbl request\n"));
-       cs46xx_suspend(s, 0);
+       cs46xx_suspend(s, state);
        return 0;
 }