tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

ALSA: PCI: Replace CONFIG_PM with CONFIG_PM_SLEEP

Otherwise we may get compile warnings due to unused functions.

Signed-off-by: Takashi Iwai <tiwai@suse.de>

Takashi Iwai c7561cd8 7ccbde57

+135 -135
+2 -2
include/sound/emu10k1.h
··· 1788 1788 unsigned int efx_voices_mask[2]; 1789 1789 unsigned int next_free_voice; 1790 1790 1791 - #ifdef CONFIG_PM 1791 + #ifdef CONFIG_PM_SLEEP 1792 1792 unsigned int *saved_ptr; 1793 1793 unsigned int *saved_gpr; 1794 1794 unsigned int *tram_val_saved; ··· 1856 1856 void snd_emu10k1_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short data); 1857 1857 unsigned int snd_emu10k1_rate_to_pitch(unsigned int rate); 1858 1858 1859 - #ifdef CONFIG_PM 1859 + #ifdef CONFIG_PM_SLEEP 1860 1860 void snd_emu10k1_suspend_regs(struct snd_emu10k1 *emu); 1861 1861 void snd_emu10k1_resume_init(struct snd_emu10k1 *emu); 1862 1862 void snd_emu10k1_resume_regs(struct snd_emu10k1 *emu);
+5 -5
sound/pci/ali5451/ali5451.c
··· 270 270 spinlock_t reg_lock; 271 271 spinlock_t voice_alloc; 272 272 273 - #ifdef CONFIG_PM 273 + #ifdef CONFIG_PM_SLEEP 274 274 struct snd_ali_image *image; 275 275 #endif 276 276 }; ··· 1883 1883 return 0; 1884 1884 } 1885 1885 1886 - #ifdef CONFIG_PM 1886 + #ifdef CONFIG_PM_SLEEP 1887 1887 static int ali_suspend(struct device *dev) 1888 1888 { 1889 1889 struct pci_dev *pci = to_pci_dev(dev); ··· 1989 1989 #define ALI_PM_OPS &ali_pm 1990 1990 #else 1991 1991 #define ALI_PM_OPS NULL 1992 - #endif /* CONFIG_PM */ 1992 + #endif /* CONFIG_PM_SLEEP */ 1993 1993 1994 1994 static int snd_ali_free(struct snd_ali * codec) 1995 1995 { ··· 2000 2000 if (codec->port) 2001 2001 pci_release_regions(codec->pci); 2002 2002 pci_disable_device(codec->pci); 2003 - #ifdef CONFIG_PM 2003 + #ifdef CONFIG_PM_SLEEP 2004 2004 kfree(codec->image); 2005 2005 #endif 2006 2006 pci_dev_put(codec->pci_m1533); ··· 2232 2232 return err; 2233 2233 } 2234 2234 2235 - #ifdef CONFIG_PM 2235 + #ifdef CONFIG_PM_SLEEP 2236 2236 codec->image = kmalloc(sizeof(*codec->image), GFP_KERNEL); 2237 2237 if (!codec->image) 2238 2238 snd_printk(KERN_WARNING "can't allocate apm buffer\n");
+1 -1
sound/pci/als300.c
··· 765 765 return 0; 766 766 } 767 767 768 - #ifdef CONFIG_PM 768 + #ifdef CONFIG_PM_SLEEP 769 769 static int snd_als300_suspend(struct device *dev) 770 770 { 771 771 struct pci_dev *pci = to_pci_dev(dev);
+2 -2
sound/pci/als4000.c
··· 987 987 pci_set_drvdata(pci, NULL); 988 988 } 989 989 990 - #ifdef CONFIG_PM 990 + #ifdef CONFIG_PM_SLEEP 991 991 static int snd_als4000_suspend(struct device *dev) 992 992 { 993 993 struct pci_dev *pci = to_pci_dev(dev); ··· 1040 1040 #define SND_ALS4000_PM_OPS &snd_als4000_pm 1041 1041 #else 1042 1042 #define SND_ALS4000_PM_OPS NULL 1043 - #endif /* CONFIG_PM */ 1043 + #endif /* CONFIG_PM_SLEEP */ 1044 1044 1045 1045 static struct pci_driver als4000_driver = { 1046 1046 .name = KBUILD_MODNAME,
+1 -1
sound/pci/asihpi/asihpi.c
··· 2968 2968 .id_table = asihpi_pci_tbl, 2969 2969 .probe = snd_asihpi_probe, 2970 2970 .remove = __devexit_p(snd_asihpi_remove), 2971 - #ifdef CONFIG_PM 2971 + #ifdef CONFIG_PM_SLEEP 2972 2972 /* .suspend = snd_asihpi_suspend, 2973 2973 .resume = snd_asihpi_resume, */ 2974 2974 #endif
+3 -3
sound/pci/atiixp.c
··· 535 535 return 0; 536 536 } 537 537 538 - #ifdef CONFIG_PM 538 + #ifdef CONFIG_PM_SLEEP 539 539 static int snd_atiixp_aclink_down(struct atiixp *chip) 540 540 { 541 541 // if (atiixp_read(chip, MODEM_MIRROR) & 0x1) /* modem running, too? */ ··· 1458 1458 } 1459 1459 1460 1460 1461 - #ifdef CONFIG_PM 1461 + #ifdef CONFIG_PM_SLEEP 1462 1462 /* 1463 1463 * power management 1464 1464 */ ··· 1533 1533 #define SND_ATIIXP_PM_OPS &snd_atiixp_pm 1534 1534 #else 1535 1535 #define SND_ATIIXP_PM_OPS NULL 1536 - #endif /* CONFIG_PM */ 1536 + #endif /* CONFIG_PM_SLEEP */ 1537 1537 1538 1538 1539 1539 #ifdef CONFIG_PROC_FS
+3 -3
sound/pci/atiixp_modem.c
··· 511 511 return 0; 512 512 } 513 513 514 - #ifdef CONFIG_PM 514 + #ifdef CONFIG_PM_SLEEP 515 515 static int snd_atiixp_aclink_down(struct atiixp_modem *chip) 516 516 { 517 517 // if (atiixp_read(chip, MODEM_MIRROR) & 0x1) /* modem running, too? */ ··· 1113 1113 } 1114 1114 1115 1115 1116 - #ifdef CONFIG_PM 1116 + #ifdef CONFIG_PM_SLEEP 1117 1117 /* 1118 1118 * power management 1119 1119 */ ··· 1169 1169 #define SND_ATIIXP_PM_OPS &snd_atiixp_pm 1170 1170 #else 1171 1171 #define SND_ATIIXP_PM_OPS NULL 1172 - #endif /* CONFIG_PM */ 1172 + #endif /* CONFIG_PM_SLEEP */ 1173 1173 1174 1174 #ifdef CONFIG_PROC_FS 1175 1175 /*
+3 -3
sound/pci/azt3328.c
··· 365 365 * CONFIG_PM register storage below, but that's slightly difficult. */ 366 366 u16 shadow_reg_ctrl_6AH; 367 367 368 - #ifdef CONFIG_PM 368 + #ifdef CONFIG_PM_SLEEP 369 369 /* register value containers for power management 370 370 * Note: not always full I/O range preserved (similar to Win driver!) */ 371 371 u32 saved_regs_ctrl[AZF_ALIGN(AZF_IO_SIZE_CTRL_PM) / 4]; ··· 2729 2729 snd_azf3328_dbgcallleave(); 2730 2730 } 2731 2731 2732 - #ifdef CONFIG_PM 2732 + #ifdef CONFIG_PM_SLEEP 2733 2733 static inline void 2734 2734 snd_azf3328_suspend_regs(unsigned long io_addr, unsigned count, u32 *saved_regs) 2735 2735 { ··· 2866 2866 #define SND_AZF3328_PM_OPS &snd_azf3328_pm 2867 2867 #else 2868 2868 #define SND_AZF3328_PM_OPS NULL 2869 - #endif /* CONFIG_PM */ 2869 + #endif /* CONFIG_PM_SLEEP */ 2870 2870 2871 2871 static struct pci_driver azf3328_driver = { 2872 2872 .name = KBUILD_MODNAME,
+2 -2
sound/pci/ca0106/ca0106.h
··· 710 710 711 711 u16 spi_dac_reg[16]; 712 712 713 - #ifdef CONFIG_PM 713 + #ifdef CONFIG_PM_SLEEP 714 714 #define NUM_SAVED_VOLUMES 9 715 715 unsigned int saved_vol[NUM_SAVED_VOLUMES]; 716 716 #endif ··· 733 733 int snd_ca0106_spi_write(struct snd_ca0106 * emu, 734 734 unsigned int data); 735 735 736 - #ifdef CONFIG_PM 736 + #ifdef CONFIG_PM_SLEEP 737 737 void snd_ca0106_mixer_suspend(struct snd_ca0106 *chip); 738 738 void snd_ca0106_mixer_resume(struct snd_ca0106 *chip); 739 739 #else
+1 -1
sound/pci/ca0106/ca0106_main.c
··· 1871 1871 pci_set_drvdata(pci, NULL); 1872 1872 } 1873 1873 1874 - #ifdef CONFIG_PM 1874 + #ifdef CONFIG_PM_SLEEP 1875 1875 static int snd_ca0106_suspend(struct device *dev) 1876 1876 { 1877 1877 struct pci_dev *pci = to_pci_dev(dev);
+2 -2
sound/pci/ca0106/ca0106_mixer.c
··· 907 907 return 0; 908 908 } 909 909 910 - #ifdef CONFIG_PM 910 + #ifdef CONFIG_PM_SLEEP 911 911 struct ca0106_vol_tbl { 912 912 unsigned int channel_id; 913 913 unsigned int reg; ··· 953 953 if (chip->details->i2c_adc) 954 954 ca0106_set_capture_mic_line_in(chip); 955 955 } 956 - #endif /* CONFIG_PM */ 956 + #endif /* CONFIG_PM_SLEEP */
+3 -3
sound/pci/cmipci.c
··· 504 504 505 505 spinlock_t reg_lock; 506 506 507 - #ifdef CONFIG_PM 507 + #ifdef CONFIG_PM_SLEEP 508 508 unsigned int saved_regs[0x20]; 509 509 unsigned char saved_mixers[0x20]; 510 510 #endif ··· 3315 3315 } 3316 3316 3317 3317 3318 - #ifdef CONFIG_PM 3318 + #ifdef CONFIG_PM_SLEEP 3319 3319 /* 3320 3320 * power management 3321 3321 */ ··· 3403 3403 #define SND_CMIPCI_PM_OPS &snd_cmipci_pm 3404 3404 #else 3405 3405 #define SND_CMIPCI_PM_OPS NULL 3406 - #endif /* CONFIG_PM */ 3406 + #endif /* CONFIG_PM_SLEEP */ 3407 3407 3408 3408 static struct pci_driver cmipci_driver = { 3409 3409 .name = KBUILD_MODNAME,
+3 -3
sound/pci/cs4281.c
··· 486 486 487 487 struct gameport *gameport; 488 488 489 - #ifdef CONFIG_PM 489 + #ifdef CONFIG_PM_SLEEP 490 490 u32 suspend_regs[SUSPEND_REGISTERS]; 491 491 #endif 492 492 ··· 1977 1977 /* 1978 1978 * Power Management 1979 1979 */ 1980 - #ifdef CONFIG_PM 1980 + #ifdef CONFIG_PM_SLEEP 1981 1981 1982 1982 static int saved_regs[SUSPEND_REGISTERS] = { 1983 1983 BA0_JSCTL, ··· 2089 2089 #define CS4281_PM_OPS &cs4281_pm 2090 2090 #else 2091 2091 #define CS4281_PM_OPS NULL 2092 - #endif /* CONFIG_PM */ 2092 + #endif /* CONFIG_PM_SLEEP */ 2093 2093 2094 2094 static struct pci_driver cs4281_driver = { 2095 2095 .name = KBUILD_MODNAME,
+1 -1
sound/pci/cs46xx/cs46xx.c
··· 166 166 .id_table = snd_cs46xx_ids, 167 167 .probe = snd_card_cs46xx_probe, 168 168 .remove = __devexit_p(snd_card_cs46xx_remove), 169 - #ifdef CONFIG_PM 169 + #ifdef CONFIG_PM_SLEEP 170 170 .driver = { 171 171 .pm = &snd_cs46xx_pm, 172 172 },
+1 -1
sound/pci/cs46xx/cs46xx.h
··· 1721 1721 unsigned int play_ctl; 1722 1722 #endif 1723 1723 1724 - #ifdef CONFIG_PM 1724 + #ifdef CONFIG_PM_SLEEP 1725 1725 u32 *saved_regs; 1726 1726 #endif 1727 1727 };
+4 -4
sound/pci/cs46xx/cs46xx_lib.c
··· 2797 2797 } 2798 2798 #endif 2799 2799 2800 - #ifdef CONFIG_PM 2800 + #ifdef CONFIG_PM_SLEEP 2801 2801 kfree(chip->saved_regs); 2802 2802 #endif 2803 2803 ··· 3590 3590 /* 3591 3591 * APM support 3592 3592 */ 3593 - #ifdef CONFIG_PM 3593 + #ifdef CONFIG_PM_SLEEP 3594 3594 static unsigned int saved_regs[] = { 3595 3595 BA0_ACOSV, 3596 3596 /*BA0_ASER_FADDR,*/ ··· 3711 3711 } 3712 3712 3713 3713 SIMPLE_DEV_PM_OPS(snd_cs46xx_pm, snd_cs46xx_suspend, snd_cs46xx_resume); 3714 - #endif /* CONFIG_PM */ 3714 + #endif /* CONFIG_PM_SLEEP */ 3715 3715 3716 3716 3717 3717 /* ··· 3868 3868 3869 3869 snd_cs46xx_proc_init(card, chip); 3870 3870 3871 - #ifdef CONFIG_PM 3871 + #ifdef CONFIG_PM_SLEEP 3872 3872 chip->saved_regs = kmalloc(sizeof(*chip->saved_regs) * 3873 3873 ARRAY_SIZE(saved_regs), GFP_KERNEL); 3874 3874 if (!chip->saved_regs) {
+1 -1
sound/pci/cs46xx/cs46xx_lib.h
··· 90 90 struct dsp_spos_instance *cs46xx_dsp_spos_create (struct snd_cs46xx * chip); 91 91 void cs46xx_dsp_spos_destroy (struct snd_cs46xx * chip); 92 92 int cs46xx_dsp_load_module (struct snd_cs46xx * chip, struct dsp_module_desc * module); 93 - #ifdef CONFIG_PM 93 + #ifdef CONFIG_PM_SLEEP 94 94 int cs46xx_dsp_resume(struct snd_cs46xx * chip); 95 95 #endif 96 96 struct dsp_symbol_entry *cs46xx_dsp_lookup_symbol (struct snd_cs46xx * chip, char * symbol_name,
+4 -4
sound/pci/cs46xx/dsp_spos.c
··· 287 287 if (ins->scbs[i].deleted) continue; 288 288 289 289 cs46xx_dsp_proc_free_scb_desc ( (ins->scbs + i) ); 290 - #ifdef CONFIG_PM 290 + #ifdef CONFIG_PM_SLEEP 291 291 kfree(ins->scbs[i].data); 292 292 #endif 293 293 } ··· 1019 1019 { 1020 1020 struct dsp_scb_descriptor * desc; 1021 1021 1022 - #ifdef CONFIG_PM 1022 + #ifdef CONFIG_PM_SLEEP 1023 1023 /* copy the data for resume */ 1024 1024 scb_data = kmemdup(scb_data, SCB_BYTES, GFP_KERNEL); 1025 1025 if (!scb_data) ··· 1032 1032 _dsp_create_scb(chip,scb_data,dest); 1033 1033 } else { 1034 1034 snd_printk(KERN_ERR "dsp_spos: failed to map SCB\n"); 1035 - #ifdef CONFIG_PM 1035 + #ifdef CONFIG_PM_SLEEP 1036 1036 kfree(scb_data); 1037 1037 #endif 1038 1038 } ··· 1937 1937 return 0; 1938 1938 } 1939 1939 1940 - #ifdef CONFIG_PM 1940 + #ifdef CONFIG_PM_SLEEP 1941 1941 int cs46xx_dsp_resume(struct snd_cs46xx * chip) 1942 1942 { 1943 1943 struct dsp_spos_instance * ins = chip->dsp_spos_instance;
+1 -1
sound/pci/cs46xx/dsp_spos_scb_lib.c
··· 203 203 remove_symbol (chip,scb->scb_symbol); 204 204 205 205 ins->scbs[scb->index].deleted = 1; 206 - #ifdef CONFIG_PM 206 + #ifdef CONFIG_PM_SLEEP 207 207 kfree(ins->scbs[scb->index].data); 208 208 ins->scbs[scb->index].data = NULL; 209 209 #endif
+1 -1
sound/pci/cs5535audio/Makefile
··· 3 3 # 4 4 5 5 snd-cs5535audio-y := cs5535audio.o cs5535audio_pcm.o 6 - snd-cs5535audio-$(CONFIG_PM) += cs5535audio_pm.o 6 + snd-cs5535audio-$(CONFIG_PM_SLEEP) += cs5535audio_pm.o 7 7 snd-cs5535audio-$(CONFIG_OLPC) += cs5535audio_olpc.o 8 8 9 9 # Toplevel Module Dependency
+1 -1
sound/pci/cs5535audio/cs5535audio.c
··· 399 399 .id_table = snd_cs5535audio_ids, 400 400 .probe = snd_cs5535audio_probe, 401 401 .remove = __devexit_p(snd_cs5535audio_remove), 402 - #ifdef CONFIG_PM 402 + #ifdef CONFIG_PM_SLEEP 403 403 .driver = { 404 404 .pm = &snd_cs5535audio_pm, 405 405 },
+2 -2
sound/pci/ctxfi/ctatc.c
··· 1536 1536 } 1537 1537 } 1538 1538 1539 - #ifdef CONFIG_PM 1539 + #ifdef CONFIG_PM_SLEEP 1540 1540 static int atc_suspend(struct ct_atc *atc) 1541 1541 { 1542 1542 int i; ··· 1647 1647 .output_switch_put = atc_output_switch_put, 1648 1648 .mic_source_switch_get = atc_mic_source_switch_get, 1649 1649 .mic_source_switch_put = atc_mic_source_switch_put, 1650 - #ifdef CONFIG_PM 1650 + #ifdef CONFIG_PM_SLEEP 1651 1651 .suspend = atc_suspend, 1652 1652 .resume = atc_resume, 1653 1653 #endif
+1 -1
sound/pci/ctxfi/ctatc.h
··· 143 143 144 144 struct ct_timer *timer; 145 145 146 - #ifdef CONFIG_PM 146 + #ifdef CONFIG_PM_SLEEP 147 147 int (*suspend)(struct ct_atc *atc); 148 148 int (*resume)(struct ct_atc *atc); 149 149 #define NUM_PCMS (NUM_CTALSADEVS - 1)
+1 -1
sound/pci/ctxfi/cthardware.h
··· 72 72 int (*card_init)(struct hw *hw, struct card_conf *info); 73 73 int (*card_stop)(struct hw *hw); 74 74 int (*pll_init)(struct hw *hw, unsigned int rsr); 75 - #ifdef CONFIG_PM 75 + #ifdef CONFIG_PM_SLEEP 76 76 int (*suspend)(struct hw *hw); 77 77 int (*resume)(struct hw *hw, struct card_conf *info); 78 78 #endif
+2 -2
sound/pci/ctxfi/cthw20k1.c
··· 2085 2085 return 0; 2086 2086 } 2087 2087 2088 - #ifdef CONFIG_PM 2088 + #ifdef CONFIG_PM_SLEEP 2089 2089 static int hw_suspend(struct hw *hw) 2090 2090 { 2091 2091 struct pci_dev *pci = hw->pci; ··· 2180 2180 .is_adc_source_selected = hw_is_adc_input_selected, 2181 2181 .select_adc_source = hw_adc_input_select, 2182 2182 .capabilities = hw_capabilities, 2183 - #ifdef CONFIG_PM 2183 + #ifdef CONFIG_PM_SLEEP 2184 2184 .suspend = hw_suspend, 2185 2185 .resume = hw_resume, 2186 2186 #endif
+2 -2
sound/pci/ctxfi/cthw20k2.c
··· 2201 2201 return 0; 2202 2202 } 2203 2203 2204 - #ifdef CONFIG_PM 2204 + #ifdef CONFIG_PM_SLEEP 2205 2205 static int hw_suspend(struct hw *hw) 2206 2206 { 2207 2207 struct pci_dev *pci = hw->pci; ··· 2250 2250 .output_switch_put = hw_output_switch_put, 2251 2251 .mic_source_switch_get = hw_mic_source_switch_get, 2252 2252 .mic_source_switch_put = hw_mic_source_switch_put, 2253 - #ifdef CONFIG_PM 2253 + #ifdef CONFIG_PM_SLEEP 2254 2254 .suspend = hw_suspend, 2255 2255 .resume = hw_resume, 2256 2256 #endif
+2 -2
sound/pci/ctxfi/ctmixer.c
··· 1118 1118 return 0; 1119 1119 } 1120 1120 1121 - #ifdef CONFIG_PM 1121 + #ifdef CONFIG_PM_SLEEP 1122 1122 static int mixer_resume(struct ct_mixer *mixer) 1123 1123 { 1124 1124 int i, state; ··· 1188 1188 mixer->get_output_ports = mixer_get_output_ports; 1189 1189 mixer->set_input_left = mixer_set_input_left; 1190 1190 mixer->set_input_right = mixer_set_input_right; 1191 - #ifdef CONFIG_PM 1191 + #ifdef CONFIG_PM_SLEEP 1192 1192 mixer->resume = mixer_resume; 1193 1193 #endif 1194 1194
+1 -1
sound/pci/ctxfi/ctmixer.h
··· 56 56 enum MIXER_PORT_T type, struct rsc *rsc); 57 57 int (*set_input_right)(struct ct_mixer *mixer, 58 58 enum MIXER_PORT_T type, struct rsc *rsc); 59 - #ifdef CONFIG_PM 59 + #ifdef CONFIG_PM_SLEEP 60 60 int (*resume)(struct ct_mixer *mixer); 61 61 #endif 62 62 };
+1 -1
sound/pci/ctxfi/ctpcm.c
··· 427 427 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG, 428 428 snd_dma_pci_data(atc->pci), 128*1024, 128*1024); 429 429 430 - #ifdef CONFIG_PM 430 + #ifdef CONFIG_PM_SLEEP 431 431 atc->pcms[device] = pcm; 432 432 #endif 433 433
+1 -1
sound/pci/ctxfi/xfi.c
··· 125 125 pci_set_drvdata(pci, NULL); 126 126 } 127 127 128 - #ifdef CONFIG_PM 128 + #ifdef CONFIG_PM_SLEEP 129 129 static int ct_card_suspend(struct device *dev) 130 130 { 131 131 struct snd_card *card = dev_get_drvdata(dev);
+6 -6
sound/pci/echoaudio/echoaudio.c
··· 46 46 int err; 47 47 char name[30]; 48 48 49 - #ifdef CONFIG_PM 49 + #ifdef CONFIG_PM_SLEEP 50 50 if (chip->fw_cache[fw_index]) { 51 51 DE_ACT(("firmware requested: %s is cached\n", card_fw[fw_index].data)); 52 52 *fw_entry = chip->fw_cache[fw_index]; ··· 59 59 err = request_firmware(fw_entry, name, pci_device(chip)); 60 60 if (err < 0) 61 61 snd_printk(KERN_ERR "get_firmware(): Firmware not available (%d)\n", err); 62 - #ifdef CONFIG_PM 62 + #ifdef CONFIG_PM_SLEEP 63 63 else 64 64 chip->fw_cache[fw_index] = *fw_entry; 65 65 #endif ··· 70 70 71 71 static void free_firmware(const struct firmware *fw_entry) 72 72 { 73 - #ifdef CONFIG_PM 73 + #ifdef CONFIG_PM_SLEEP 74 74 DE_ACT(("firmware not released (kept in cache)\n")); 75 75 #else 76 76 release_firmware(fw_entry); ··· 82 82 83 83 static void free_firmware_cache(struct echoaudio *chip) 84 84 { 85 - #ifdef CONFIG_PM 85 + #ifdef CONFIG_PM_SLEEP 86 86 int i; 87 87 88 88 for (i = 0; i < 8 ; i++) ··· 2203 2203 2204 2204 2205 2205 2206 - #if defined(CONFIG_PM) 2206 + #if defined(CONFIG_PM_SLEEP) 2207 2207 2208 2208 static int snd_echo_suspend(struct device *dev) 2209 2209 { ··· 2313 2313 #define SND_ECHO_PM_OPS &snd_echo_pm 2314 2314 #else 2315 2315 #define SND_ECHO_PM_OPS NULL 2316 - #endif /* CONFIG_PM */ 2316 + #endif /* CONFIG_PM_SLEEP */ 2317 2317 2318 2318 2319 2319 static void __devexit snd_echo_remove(struct pci_dev *pci)
+1 -1
sound/pci/echoaudio/echoaudio.h
··· 449 449 volatile u32 __iomem *dsp_registers; /* DSP's register base */ 450 450 u32 active_mask; /* Chs. active mask or 451 451 * punks out */ 452 - #ifdef CONFIG_PM 452 + #ifdef CONFIG_PM_SLEEP 453 453 const struct firmware *fw_cache[8]; /* Cached firmwares */ 454 454 #endif 455 455
+2 -2
sound/pci/emu10k1/emu10k1.c
··· 206 206 } 207 207 208 208 209 - #ifdef CONFIG_PM 209 + #ifdef CONFIG_PM_SLEEP 210 210 static int snd_emu10k1_suspend(struct device *dev) 211 211 { 212 212 struct pci_dev *pci = to_pci_dev(dev); ··· 268 268 #define SND_EMU10K1_PM_OPS &snd_emu10k1_pm 269 269 #else 270 270 #define SND_EMU10K1_PM_OPS NULL 271 - #endif /* CONFIG_PM */ 271 + #endif /* CONFIG_PM_SLEEP */ 272 272 273 273 static struct pci_driver emu10k1_driver = { 274 274 .name = KBUILD_MODNAME,
+4 -4
sound/pci/emu10k1/emu10k1_main.c
··· 1241 1241 * Create the EMU10K1 instance 1242 1242 */ 1243 1243 1244 - #ifdef CONFIG_PM 1244 + #ifdef CONFIG_PM_SLEEP 1245 1245 static int alloc_pm_buffer(struct snd_emu10k1 *emu); 1246 1246 static void free_pm_buffer(struct snd_emu10k1 *emu); 1247 1247 #endif ··· 1275 1275 snd_dma_free_pages(&emu->ptb_pages); 1276 1276 vfree(emu->page_ptr_table); 1277 1277 vfree(emu->page_addr_table); 1278 - #ifdef CONFIG_PM 1278 + #ifdef CONFIG_PM_SLEEP 1279 1279 free_pm_buffer(emu); 1280 1280 #endif 1281 1281 if (emu->port) ··· 1971 1971 err = snd_emu10k1_init(emu, enable_ir, 0); 1972 1972 if (err < 0) 1973 1973 goto error; 1974 - #ifdef CONFIG_PM 1974 + #ifdef CONFIG_PM_SLEEP 1975 1975 err = alloc_pm_buffer(emu); 1976 1976 if (err < 0) 1977 1977 goto error; ··· 2000 2000 return err; 2001 2001 } 2002 2002 2003 - #ifdef CONFIG_PM 2003 + #ifdef CONFIG_PM_SLEEP 2004 2004 static unsigned char saved_regs[] = { 2005 2005 CPF, PTRX, CVCF, VTFT, Z1, Z2, PSST, DSL, CCCA, CCR, CLP, 2006 2006 FXRT, MAPA, MAPB, ENVVOL, ATKHLDV, DCYSUSV, LFOVAL1, ENVVAL,
+1 -1
sound/pci/emu10k1/emufx.c
··· 2646 2646 return 0; 2647 2647 } 2648 2648 2649 - #ifdef CONFIG_PM 2649 + #ifdef CONFIG_PM_SLEEP 2650 2650 int __devinit snd_emu10k1_efx_alloc_pm_buffer(struct snd_emu10k1 *emu) 2651 2651 { 2652 2652 int len;
+1 -1
sound/pci/emu10k1/p16v.c
··· 893 893 return 0; 894 894 } 895 895 896 - #ifdef CONFIG_PM 896 + #ifdef CONFIG_PM_SLEEP 897 897 898 898 #define NUM_CHS 1 /* up to 4, but only first channel is used */ 899 899
+2 -2
sound/pci/ens1370.c
··· 2032 2032 synchronize_irq(ensoniq->irq); 2033 2033 } 2034 2034 2035 - #ifdef CONFIG_PM 2035 + #ifdef CONFIG_PM_SLEEP 2036 2036 static int snd_ensoniq_suspend(struct device *dev) 2037 2037 { 2038 2038 struct pci_dev *pci = to_pci_dev(dev); ··· 2094 2094 #define SND_ENSONIQ_PM_OPS &snd_ensoniq_pm 2095 2095 #else 2096 2096 #define SND_ENSONIQ_PM_OPS NULL 2097 - #endif /* CONFIG_PM */ 2097 + #endif /* CONFIG_PM_SLEEP */ 2098 2098 2099 2099 static int __devinit snd_ensoniq_create(struct snd_card *card, 2100 2100 struct pci_dev *pci,
+3 -3
sound/pci/es1938.c
··· 236 236 #ifdef SUPPORT_JOYSTICK 237 237 struct gameport *gameport; 238 238 #endif 239 - #ifdef CONFIG_PM 239 + #ifdef CONFIG_PM_SLEEP 240 240 unsigned char saved_regs[SAVED_REG_SIZE]; 241 241 #endif 242 242 }; ··· 1456 1456 outb(0, SLDM_REG(chip, DMACLEAR)); 1457 1457 } 1458 1458 1459 - #ifdef CONFIG_PM 1459 + #ifdef CONFIG_PM_SLEEP 1460 1460 /* 1461 1461 * PM support 1462 1462 */ ··· 1536 1536 #define ES1938_PM_OPS &es1938_pm 1537 1537 #else 1538 1538 #define ES1938_PM_OPS NULL 1539 - #endif /* CONFIG_PM */ 1539 + #endif /* CONFIG_PM_SLEEP */ 1540 1540 1541 1541 #ifdef SUPPORT_JOYSTICK 1542 1542 static int __devinit snd_es1938_create_gameport(struct es1938 *chip)
+6 -6
sound/pci/es1968.c
··· 491 491 /* linked list */ 492 492 struct list_head list; 493 493 494 - #ifdef CONFIG_PM 494 + #ifdef CONFIG_PM_SLEEP 495 495 u16 wc_map[4]; 496 496 #endif 497 497 }; ··· 544 544 struct list_head substream_list; 545 545 spinlock_t substream_lock; 546 546 547 - #ifdef CONFIG_PM 547 + #ifdef CONFIG_PM_SLEEP 548 548 u16 apu_map[NR_APUS][NR_APU_REGS]; 549 549 #endif 550 550 ··· 706 706 { 707 707 if (snd_BUG_ON(channel >= NR_APUS)) 708 708 return; 709 - #ifdef CONFIG_PM 709 + #ifdef CONFIG_PM_SLEEP 710 710 chip->apu_map[channel][reg] = data; 711 711 #endif 712 712 reg |= (channel << 4); ··· 993 993 /* set the wavecache control reg */ 994 994 wave_set_register(chip, es->apu[channel] << 3, tmpval); 995 995 996 - #ifdef CONFIG_PM 996 + #ifdef CONFIG_PM_SLEEP 997 997 es->wc_map[channel] = tmpval; 998 998 #endif 999 999 } ··· 2377 2377 outw(w, chip->io_port + ESM_PORT_HOST_IRQ); 2378 2378 } 2379 2379 2380 - #ifdef CONFIG_PM 2380 + #ifdef CONFIG_PM_SLEEP 2381 2381 /* 2382 2382 * PM support 2383 2383 */ ··· 2461 2461 #define ES1968_PM_OPS &es1968_pm 2462 2462 #else 2463 2463 #define ES1968_PM_OPS NULL 2464 - #endif /* CONFIG_PM */ 2464 + #endif /* CONFIG_PM_SLEEP */ 2465 2465 2466 2466 #ifdef SUPPORT_JOYSTICK 2467 2467 #define JOYSTICK_ADDR 0x200
+3 -3
sound/pci/fm801.c
··· 205 205 struct snd_tea575x tea; 206 206 #endif 207 207 208 - #ifdef CONFIG_PM 208 + #ifdef CONFIG_PM_SLEEP 209 209 u16 saved_regs[0x20]; 210 210 #endif 211 211 }; ··· 1361 1361 pci_set_drvdata(pci, NULL); 1362 1362 } 1363 1363 1364 - #ifdef CONFIG_PM 1364 + #ifdef CONFIG_PM_SLEEP 1365 1365 static unsigned char saved_regs[] = { 1366 1366 FM801_PCM_VOL, FM801_I2S_VOL, FM801_FM_VOL, FM801_REC_SRC, 1367 1367 FM801_PLY_CTRL, FM801_PLY_COUNT, FM801_PLY_BUF1, FM801_PLY_BUF2, ··· 1421 1421 #define SND_FM801_PM_OPS &snd_fm801_pm 1422 1422 #else 1423 1423 #define SND_FM801_PM_OPS NULL 1424 - #endif /* CONFIG_PM */ 1424 + #endif /* CONFIG_PM_SLEEP */ 1425 1425 1426 1426 static struct pci_driver fm801_driver = { 1427 1427 .name = KBUILD_MODNAME,
+2 -2
sound/pci/ice1712/aureon.c
··· 2103 2103 /* 2104 2104 * suspend/resume 2105 2105 */ 2106 - #ifdef CONFIG_PM 2106 + #ifdef CONFIG_PM_SLEEP 2107 2107 static int aureon_resume(struct snd_ice1712 *ice) 2108 2108 { 2109 2109 struct aureon_spec *spec = ice->spec; ··· 2160 2160 wm_set_vol(ice, i, spec->vol[i], spec->master[i % 2]); 2161 2161 } 2162 2162 2163 - #ifdef CONFIG_PM 2163 + #ifdef CONFIG_PM_SLEEP 2164 2164 ice->pm_resume = aureon_resume; 2165 2165 ice->pm_suspend_enabled = 1; 2166 2166 #endif
+1 -1
sound/pci/ice1712/ice1712.h
··· 384 384 char **ext_clock_names; 385 385 int ext_clock_count; 386 386 void (*pro_open)(struct snd_ice1712 *, struct snd_pcm_substream *); 387 - #ifdef CONFIG_PM 387 + #ifdef CONFIG_PM_SLEEP 388 388 int (*pm_suspend)(struct snd_ice1712 *); 389 389 int (*pm_resume)(struct snd_ice1712 *); 390 390 unsigned int pm_suspend_enabled:1;
+2 -2
sound/pci/ice1712/ice1724.c
··· 2792 2792 pci_set_drvdata(pci, NULL); 2793 2793 } 2794 2794 2795 - #ifdef CONFIG_PM 2795 + #ifdef CONFIG_PM_SLEEP 2796 2796 static int snd_vt1724_suspend(struct device *dev) 2797 2797 { 2798 2798 struct pci_dev *pci = to_pci_dev(dev); ··· 2878 2878 #define SND_VT1724_PM_OPS &snd_vt1724_pm 2879 2879 #else 2880 2880 #define SND_VT1724_PM_OPS NULL 2881 - #endif /* CONFIG_PM */ 2881 + #endif /* CONFIG_PM_SLEEP */ 2882 2882 2883 2883 static struct pci_driver vt1724_driver = { 2884 2884 .name = KBUILD_MODNAME,
+2 -2
sound/pci/ice1712/juli.c
··· 486 486 * suspend/resume 487 487 * */ 488 488 489 - #ifdef CONFIG_PM 489 + #ifdef CONFIG_PM_SLEEP 490 490 static int juli_resume(struct snd_ice1712 *ice) 491 491 { 492 492 struct snd_akm4xxx *ak = ice->akm; ··· 652 652 653 653 ice->spdif.ops.open = juli_spdif_in_open; 654 654 655 - #ifdef CONFIG_PM 655 + #ifdef CONFIG_PM_SLEEP 656 656 ice->pm_resume = juli_resume; 657 657 ice->pm_suspend = juli_suspend; 658 658 ice->pm_suspend_enabled = 1;
+2 -2
sound/pci/ice1712/prodigy_hifi.c
··· 1099 1099 ak4396_write(ice, ak4396_inits[i], ak4396_inits[i+1]); 1100 1100 } 1101 1101 1102 - #ifdef CONFIG_PM 1102 + #ifdef CONFIG_PM_SLEEP 1103 1103 static int prodigy_hd2_resume(struct snd_ice1712 *ice) 1104 1104 { 1105 1105 /* initialize ak4396 codec and restore previous mixer volumes */ ··· 1140 1140 return -ENOMEM; 1141 1141 ice->spec = spec; 1142 1142 1143 - #ifdef CONFIG_PM 1143 + #ifdef CONFIG_PM_SLEEP 1144 1144 ice->pm_resume = &prodigy_hd2_resume; 1145 1145 ice->pm_suspend_enabled = 1; 1146 1146 #endif
+2 -2
sound/pci/intel8x0.c
··· 2620 2620 return 0; 2621 2621 } 2622 2622 2623 - #ifdef CONFIG_PM 2623 + #ifdef CONFIG_PM_SLEEP 2624 2624 /* 2625 2625 * power management 2626 2626 */ ··· 2741 2741 #define INTEL8X0_PM_OPS &intel8x0_pm 2742 2742 #else 2743 2743 #define INTEL8X0_PM_OPS NULL 2744 - #endif /* CONFIG_PM */ 2744 + #endif /* CONFIG_PM_SLEEP */ 2745 2745 2746 2746 #define INTEL8X0_TESTBUF_SIZE 32768 /* enough large for one shot */ 2747 2747
+2 -2
sound/pci/intel8x0m.c
··· 1008 1008 return 0; 1009 1009 } 1010 1010 1011 - #ifdef CONFIG_PM 1011 + #ifdef CONFIG_PM_SLEEP 1012 1012 /* 1013 1013 * power management 1014 1014 */ ··· 1067 1067 #define INTEL8X0M_PM_OPS &intel8x0m_pm 1068 1068 #else 1069 1069 #define INTEL8X0M_PM_OPS NULL 1070 - #endif /* CONFIG_PM */ 1070 + #endif /* CONFIG_PM_SLEEP */ 1071 1071 1072 1072 #ifdef CONFIG_PROC_FS 1073 1073 static void snd_intel8x0m_proc_read(struct snd_info_entry * entry,
+5 -5
sound/pci/maestro3.c
··· 789 789 790 790 unsigned int in_suspend; 791 791 792 - #ifdef CONFIG_PM 792 + #ifdef CONFIG_PM_SLEEP 793 793 u16 *suspend_mem; 794 794 #endif 795 795 ··· 2368 2368 outw(0, chip->iobase + HOST_INT_CTRL); /* disable ints */ 2369 2369 } 2370 2370 2371 - #ifdef CONFIG_PM 2371 + #ifdef CONFIG_PM_SLEEP 2372 2372 vfree(chip->suspend_mem); 2373 2373 #endif 2374 2374 ··· 2390 2390 /* 2391 2391 * APM support 2392 2392 */ 2393 - #ifdef CONFIG_PM 2393 + #ifdef CONFIG_PM_SLEEP 2394 2394 static int m3_suspend(struct device *dev) 2395 2395 { 2396 2396 struct pci_dev *pci = to_pci_dev(dev); ··· 2485 2485 #define M3_PM_OPS &m3_pm 2486 2486 #else 2487 2487 #define M3_PM_OPS NULL 2488 - #endif /* CONFIG_PM */ 2488 + #endif /* CONFIG_PM_SLEEP */ 2489 2489 2490 2490 #ifdef CONFIG_SND_MAESTRO3_INPUT 2491 2491 static int __devinit snd_m3_input_register(struct snd_m3 *chip) ··· 2656 2656 } 2657 2657 chip->irq = pci->irq; 2658 2658 2659 - #ifdef CONFIG_PM 2659 + #ifdef CONFIG_PM_SLEEP 2660 2660 chip->suspend_mem = vmalloc(sizeof(u16) * (REV_B_CODE_MEMORY_LENGTH + REV_B_DATA_MEMORY_LENGTH)); 2661 2661 if (chip->suspend_mem == NULL) 2662 2662 snd_printk(KERN_WARNING "can't allocate apm buffer\n");
+2 -2
sound/pci/nm256/nm256.c
··· 1377 1377 return 0; 1378 1378 } 1379 1379 1380 - #ifdef CONFIG_PM 1380 + #ifdef CONFIG_PM_SLEEP 1381 1381 /* 1382 1382 * APM event handler, so the card is properly reinitialized after a power 1383 1383 * event. ··· 1441 1441 #define NM256_PM_OPS &nm256_pm 1442 1442 #else 1443 1443 #define NM256_PM_OPS NULL 1444 - #endif /* CONFIG_PM */ 1444 + #endif /* CONFIG_PM_SLEEP */ 1445 1445 1446 1446 static int snd_nm256_free(struct nm256 *chip) 1447 1447 {
+1 -1
sound/pci/oxygen/oxygen.c
··· 872 872 .id_table = oxygen_ids, 873 873 .probe = generic_oxygen_probe, 874 874 .remove = __devexit_p(oxygen_pci_remove), 875 - #ifdef CONFIG_PM 875 + #ifdef CONFIG_PM_SLEEP 876 876 .driver = { 877 877 .pm = &oxygen_pci_pm, 878 878 },
+1 -1
sound/pci/oxygen/oxygen.h
··· 161 161 ) 162 162 ); 163 163 void oxygen_pci_remove(struct pci_dev *pci); 164 - #ifdef CONFIG_PM 164 + #ifdef CONFIG_PM_SLEEP 165 165 extern const struct dev_pm_ops oxygen_pci_pm; 166 166 #endif 167 167 void oxygen_pci_shutdown(struct pci_dev *pci);
+2 -2
sound/pci/oxygen/oxygen_lib.c
··· 726 726 } 727 727 EXPORT_SYMBOL(oxygen_pci_remove); 728 728 729 - #ifdef CONFIG_PM 729 + #ifdef CONFIG_PM_SLEEP 730 730 static int oxygen_pci_suspend(struct device *dev) 731 731 { 732 732 struct pci_dev *pci = to_pci_dev(dev); ··· 824 824 825 825 SIMPLE_DEV_PM_OPS(oxygen_pci_pm, oxygen_pci_suspend, oxygen_pci_resume); 826 826 EXPORT_SYMBOL(oxygen_pci_pm); 827 - #endif /* CONFIG_PM */ 827 + #endif /* CONFIG_PM_SLEEP */ 828 828 829 829 void oxygen_pci_shutdown(struct pci_dev *pci) 830 830 {
+1 -1
sound/pci/oxygen/virtuoso.c
··· 93 93 .id_table = xonar_ids, 94 94 .probe = xonar_probe, 95 95 .remove = __devexit_p(oxygen_pci_remove), 96 - #ifdef CONFIG_PM 96 + #ifdef CONFIG_PM_SLEEP 97 97 .driver = { 98 98 .pm = &oxygen_pci_pm, 99 99 },
+3 -3
sound/pci/riptide/riptide.c
··· 464 464 465 465 unsigned long received_irqs; 466 466 unsigned long handled_irqs; 467 - #ifdef CONFIG_PM 467 + #ifdef CONFIG_PM_SLEEP 468 468 int in_suspend; 469 469 #endif 470 470 }; ··· 1150 1150 } 1151 1151 } 1152 1152 1153 - #ifdef CONFIG_PM 1153 + #ifdef CONFIG_PM_SLEEP 1154 1154 static int riptide_suspend(struct device *dev) 1155 1155 { 1156 1156 struct pci_dev *pci = to_pci_dev(dev); ··· 1193 1193 #define RIPTIDE_PM_OPS &riptide_pm 1194 1194 #else 1195 1195 #define RIPTIDE_PM_OPS NULL 1196 - #endif /* CONFIG_PM */ 1196 + #endif /* CONFIG_PM_SLEEP */ 1197 1197 1198 1198 static int try_to_load_firmware(struct cmdif *cif, struct snd_riptide *chip) 1199 1199 {
+3 -3
sound/pci/sis7019.c
··· 103 103 * we're not doing power management, we still need to allocate a page 104 104 * for the silence buffer. 105 105 */ 106 - #ifdef CONFIG_PM 106 + #ifdef CONFIG_PM_SLEEP 107 107 #define SIS_SUSPEND_PAGES 4 108 108 #else 109 109 #define SIS_SUSPEND_PAGES 1 ··· 1208 1208 return 0; 1209 1209 } 1210 1210 1211 - #ifdef CONFIG_PM 1211 + #ifdef CONFIG_PM_SLEEP 1212 1212 static int sis_suspend(struct device *dev) 1213 1213 { 1214 1214 struct pci_dev *pci = to_pci_dev(dev); ··· 1305 1305 #define SIS_PM_OPS &sis_pm 1306 1306 #else 1307 1307 #define SIS_PM_OPS NULL 1308 - #endif /* CONFIG_PM */ 1308 + #endif /* CONFIG_PM_SLEEP */ 1309 1309 1310 1310 static int sis_alloc_suspend(struct sis7019 *sis) 1311 1311 {
+1 -1
sound/pci/trident/trident.c
··· 177 177 .id_table = snd_trident_ids, 178 178 .probe = snd_trident_probe, 179 179 .remove = __devexit_p(snd_trident_remove), 180 - #ifdef CONFIG_PM 180 + #ifdef CONFIG_PM_SLEEP 181 181 .driver = { 182 182 .pm = &snd_trident_pm, 183 183 },
+2 -2
sound/pci/trident/trident_main.c
··· 3919 3919 } 3920 3920 } 3921 3921 3922 - #ifdef CONFIG_PM 3922 + #ifdef CONFIG_PM_SLEEP 3923 3923 static int snd_trident_suspend(struct device *dev) 3924 3924 { 3925 3925 struct pci_dev *pci = to_pci_dev(dev); ··· 3983 3983 } 3984 3984 3985 3985 SIMPLE_DEV_PM_OPS(snd_trident_pm, snd_trident_suspend, snd_trident_resume); 3986 - #endif /* CONFIG_PM */ 3986 + #endif /* CONFIG_PM_SLEEP */
+5 -5
sound/pci/via82xx.c
··· 362 362 363 363 unsigned char old_legacy; 364 364 unsigned char old_legacy_cfg; 365 - #ifdef CONFIG_PM 365 + #ifdef CONFIG_PM_SLEEP 366 366 unsigned char legacy_saved; 367 367 unsigned char legacy_cfg_saved; 368 368 unsigned char spdif_ctrl_saved; ··· 2038 2038 if (mpu_port >= 0x200) { /* force MIDI */ 2039 2039 mpu_port &= 0xfffc; 2040 2040 pci_write_config_dword(chip->pci, 0x18, mpu_port | 0x01); 2041 - #ifdef CONFIG_PM 2041 + #ifdef CONFIG_PM_SLEEP 2042 2042 chip->mpu_port_saved = mpu_port; 2043 2043 #endif 2044 2044 } else { ··· 2090 2090 2091 2091 snd_via686_create_gameport(chip, &legacy); 2092 2092 2093 - #ifdef CONFIG_PM 2093 + #ifdef CONFIG_PM_SLEEP 2094 2094 chip->legacy_saved = legacy; 2095 2095 chip->legacy_cfg_saved = legacy_cfg; 2096 2096 #endif ··· 2238 2238 return 0; 2239 2239 } 2240 2240 2241 - #ifdef CONFIG_PM 2241 + #ifdef CONFIG_PM_SLEEP 2242 2242 /* 2243 2243 * power management 2244 2244 */ ··· 2313 2313 #define SND_VIA82XX_PM_OPS &snd_via82xx_pm 2314 2314 #else 2315 2315 #define SND_VIA82XX_PM_OPS NULL 2316 - #endif /* CONFIG_PM */ 2316 + #endif /* CONFIG_PM_SLEEP */ 2317 2317 2318 2318 static int snd_via82xx_free(struct via82xx *chip) 2319 2319 {
+2 -2
sound/pci/via82xx_modem.c
··· 1019 1019 return 0; 1020 1020 } 1021 1021 1022 - #ifdef CONFIG_PM 1022 + #ifdef CONFIG_PM_SLEEP 1023 1023 /* 1024 1024 * power management 1025 1025 */ ··· 1076 1076 #define SND_VIA82XX_PM_OPS &snd_via82xx_pm 1077 1077 #else 1078 1078 #define SND_VIA82XX_PM_OPS NULL 1079 - #endif /* CONFIG_PM */ 1079 + #endif /* CONFIG_PM_SLEEP */ 1080 1080 1081 1081 static int snd_via82xx_free(struct via82xx_modem *chip) 1082 1082 {
+1 -1
sound/pci/vx222/vx222.c
··· 257 257 pci_set_drvdata(pci, NULL); 258 258 } 259 259 260 - #ifdef CONFIG_PM 260 + #ifdef CONFIG_PM_SLEEP 261 261 static int snd_vx222_suspend(struct device *dev) 262 262 { 263 263 struct pci_dev *pci = to_pci_dev(dev);
+1 -1
sound/pci/ymfpci/ymfpci.c
··· 355 355 .id_table = snd_ymfpci_ids, 356 356 .probe = snd_card_ymfpci_probe, 357 357 .remove = __devexit_p(snd_card_ymfpci_remove), 358 - #ifdef CONFIG_PM 358 + #ifdef CONFIG_PM_SLEEP 359 359 .driver = { 360 360 .pm = &snd_ymfpci_pm, 361 361 },
+1 -1
sound/pci/ymfpci/ymfpci.h
··· 363 363 const struct firmware *dsp_microcode; 364 364 const struct firmware *controller_microcode; 365 365 366 - #ifdef CONFIG_PM 366 + #ifdef CONFIG_PM_SLEEP 367 367 u32 *saved_regs; 368 368 u32 saved_ydsxgr_mode; 369 369 u16 saved_dsxg_legacy;
+4 -4
sound/pci/ymfpci/ymfpci_main.c
··· 2242 2242 pci_set_power_state(chip->pci, 3); 2243 2243 #endif 2244 2244 2245 - #ifdef CONFIG_PM 2245 + #ifdef CONFIG_PM_SLEEP 2246 2246 vfree(chip->saved_regs); 2247 2247 #endif 2248 2248 if (chip->irq >= 0) ··· 2272 2272 return snd_ymfpci_free(chip); 2273 2273 } 2274 2274 2275 - #ifdef CONFIG_PM 2275 + #ifdef CONFIG_PM_SLEEP 2276 2276 static int saved_regs_index[] = { 2277 2277 /* spdif */ 2278 2278 YDSXGR_SPDIFOUTCTRL, ··· 2374 2374 } 2375 2375 2376 2376 SIMPLE_DEV_PM_OPS(snd_ymfpci_pm, snd_ymfpci_suspend, snd_ymfpci_resume); 2377 - #endif /* CONFIG_PM */ 2377 + #endif /* CONFIG_PM_SLEEP */ 2378 2378 2379 2379 int __devinit snd_ymfpci_create(struct snd_card *card, 2380 2380 struct pci_dev * pci, ··· 2452 2452 return err; 2453 2453 } 2454 2454 2455 - #ifdef CONFIG_PM 2455 + #ifdef CONFIG_PM_SLEEP 2456 2456 chip->saved_regs = vmalloc(YDSXGR_NUM_SAVED_REGS * sizeof(u32)); 2457 2457 if (chip->saved_regs == NULL) { 2458 2458 snd_ymfpci_free(chip);