1 // SPDX-License-Identifier: GPL-2.0 1 // SPDX-License-Identifier: GPL-2.0
2 /* 2 /*
3 * UAC3 Power Domain state management functi 3 * UAC3 Power Domain state management functions
4 */ 4 */
5 5
6 #include <linux/slab.h> 6 #include <linux/slab.h>
7 #include <linux/usb.h> 7 #include <linux/usb.h>
8 #include <linux/usb/audio.h> 8 #include <linux/usb/audio.h>
9 #include <linux/usb/audio-v2.h> 9 #include <linux/usb/audio-v2.h>
10 #include <linux/usb/audio-v3.h> 10 #include <linux/usb/audio-v3.h>
11 11
12 #include "usbaudio.h" 12 #include "usbaudio.h"
13 #include "helper.h" 13 #include "helper.h"
14 #include "power.h" 14 #include "power.h"
15 15
16 struct snd_usb_power_domain * 16 struct snd_usb_power_domain *
17 snd_usb_find_power_domain(struct usb_host_inte 17 snd_usb_find_power_domain(struct usb_host_interface *ctrl_iface,
18 unsigned char id) 18 unsigned char id)
19 { 19 {
20 struct snd_usb_power_domain *pd; 20 struct snd_usb_power_domain *pd;
21 void *p; 21 void *p;
22 22
23 pd = kzalloc(sizeof(*pd), GFP_KERNEL); 23 pd = kzalloc(sizeof(*pd), GFP_KERNEL);
24 if (!pd) 24 if (!pd)
25 return NULL; 25 return NULL;
26 26
27 p = NULL; 27 p = NULL;
28 while ((p = snd_usb_find_csint_desc(ct 28 while ((p = snd_usb_find_csint_desc(ctrl_iface->extra,
29 ct 29 ctrl_iface->extralen,
30 p, 30 p, UAC3_POWER_DOMAIN)) != NULL) {
31 struct uac3_power_domain_descr 31 struct uac3_power_domain_descriptor *pd_desc = p;
32 int i; 32 int i;
33 33
34 if (!snd_usb_validate_audio_de 34 if (!snd_usb_validate_audio_desc(p, UAC_VERSION_3))
35 continue; 35 continue;
36 for (i = 0; i < pd_desc->bNrEn 36 for (i = 0; i < pd_desc->bNrEntities; i++) {
37 if (pd_desc->baEntityI 37 if (pd_desc->baEntityID[i] == id) {
38 pd->pd_id = pd 38 pd->pd_id = pd_desc->bPowerDomainID;
39 pd->pd_d1d0_re 39 pd->pd_d1d0_rec =
40 le16_t 40 le16_to_cpu(pd_desc->waRecoveryTime1);
41 pd->pd_d2d0_re 41 pd->pd_d2d0_rec =
42 le16_t 42 le16_to_cpu(pd_desc->waRecoveryTime2);
43 pd->ctrl_iface 43 pd->ctrl_iface = ctrl_iface;
44 return pd; 44 return pd;
45 } 45 }
46 } 46 }
47 } 47 }
48 48
49 kfree(pd); 49 kfree(pd);
50 return NULL; 50 return NULL;
51 } 51 }
52 52
53 int snd_usb_power_domain_set(struct snd_usb_au 53 int snd_usb_power_domain_set(struct snd_usb_audio *chip,
54 struct snd_usb_po 54 struct snd_usb_power_domain *pd,
55 unsigned char sta 55 unsigned char state)
56 { 56 {
57 struct usb_device *dev = chip->dev; 57 struct usb_device *dev = chip->dev;
58 unsigned char current_state; 58 unsigned char current_state;
59 int err, idx; 59 int err, idx;
60 60
61 idx = snd_usb_ctrl_intf(pd->ctrl_iface 61 idx = snd_usb_ctrl_intf(pd->ctrl_iface) | (pd->pd_id << 8);
62 62
63 err = snd_usb_ctl_msg(chip->dev, usb_r 63 err = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0),
64 UAC2_CS_CUR, 64 UAC2_CS_CUR,
65 USB_RECIP_INTERF 65 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
66 UAC3_AC_POWER_DO 66 UAC3_AC_POWER_DOMAIN_CONTROL << 8, idx,
67 ¤t_state, 67 ¤t_state, sizeof(current_state));
68 if (err < 0) { 68 if (err < 0) {
69 dev_err(&dev->dev, "Can't get 69 dev_err(&dev->dev, "Can't get UAC3 power state for id %d\n",
70 pd->pd_id); 70 pd->pd_id);
71 return err; 71 return err;
72 } 72 }
73 73
74 if (current_state == state) { 74 if (current_state == state) {
75 dev_dbg(&dev->dev, "UAC3 power 75 dev_dbg(&dev->dev, "UAC3 power domain id %d already in state %d\n",
76 pd->pd_id, state); 76 pd->pd_id, state);
77 return 0; 77 return 0;
78 } 78 }
79 79
80 err = snd_usb_ctl_msg(chip->dev, usb_s 80 err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC2_CS_CUR,
81 USB_RECIP_INTERF 81 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
82 UAC3_AC_POWER_DO 82 UAC3_AC_POWER_DOMAIN_CONTROL << 8, idx,
83 &state, sizeof(s 83 &state, sizeof(state));
84 if (err < 0) { 84 if (err < 0) {
85 dev_err(&dev->dev, "Can't set 85 dev_err(&dev->dev, "Can't set UAC3 power state to %d for id %d\n",
86 state, pd->pd_id); 86 state, pd->pd_id);
87 return err; 87 return err;
88 } 88 }
89 89
90 if (state == UAC3_PD_STATE_D0) { 90 if (state == UAC3_PD_STATE_D0) {
91 switch (current_state) { 91 switch (current_state) {
92 case UAC3_PD_STATE_D2: 92 case UAC3_PD_STATE_D2:
93 udelay(pd->pd_d2d0_rec 93 udelay(pd->pd_d2d0_rec * 50);
94 break; 94 break;
95 case UAC3_PD_STATE_D1: 95 case UAC3_PD_STATE_D1:
96 udelay(pd->pd_d1d0_rec 96 udelay(pd->pd_d1d0_rec * 50);
97 break; 97 break;
98 default: 98 default:
99 return -EINVAL; 99 return -EINVAL;
100 } 100 }
101 } 101 }
102 102
103 dev_dbg(&dev->dev, "UAC3 power domain 103 dev_dbg(&dev->dev, "UAC3 power domain id %d change to state %d\n",
104 pd->pd_id, state); 104 pd->pd_id, state);
105 105
106 return 0; 106 return 0;
107 } 107 }
108 108
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.