1/* SPDX-License-Identifier: GPL-2.0-or-later */
2
3#ifndef _UFSHCD_PRIV_H_
4#define _UFSHCD_PRIV_H_
5
6#include <linux/pm_runtime.h>
7#include <ufs/ufshcd.h>
8
9static inline bool ufshcd_is_user_access_allowed(struct ufs_hba *hba)
10{
11 return !hba->shutting_down;
12}
13
14void ufshcd_schedule_eh_work(struct ufs_hba *hba);
15
16static inline bool ufshcd_keep_autobkops_enabled_except_suspend(
17 struct ufs_hba *hba)
18{
19 return hba->caps & UFSHCD_CAP_KEEP_AUTO_BKOPS_ENABLED_EXCEPT_SUSPEND;
20}
21
22static inline u8 ufshcd_wb_get_query_index(struct ufs_hba *hba)
23{
24 if (hba->dev_info.wb_buffer_type == WB_BUF_MODE_LU_DEDICATED)
25 return hba->dev_info.wb_dedicated_lu;
26 return 0;
27}
28
29static inline bool ufshcd_is_wb_buf_flush_allowed(struct ufs_hba *hba)
30{
31 return ufshcd_is_wb_allowed(hba) &&
32 !(hba->quirks & UFSHCI_QUIRK_SKIP_MANUAL_WB_FLUSH_CTRL);
33}
34
35#ifdef CONFIG_SCSI_UFS_HWMON
36void ufs_hwmon_probe(struct ufs_hba *hba, u8 mask);
37void ufs_hwmon_remove(struct ufs_hba *hba);
38void ufs_hwmon_notify_event(struct ufs_hba *hba, u8 ee_mask);
39#else
40static inline void ufs_hwmon_probe(struct ufs_hba *hba, u8 mask) {}
41static inline void ufs_hwmon_remove(struct ufs_hba *hba) {}
42static inline void ufs_hwmon_notify_event(struct ufs_hba *hba, u8 ee_mask) {}
43#endif
44
45int ufshcd_query_descriptor_retry(struct ufs_hba *hba,
46 enum query_opcode opcode,
47 enum desc_idn idn, u8 index,
48 u8 selector,
49 u8 *desc_buf, int *buf_len);
50int ufshcd_read_desc_param(struct ufs_hba *hba,
51 enum desc_idn desc_id,
52 int desc_index,
53 u8 param_offset,
54 u8 *param_read_buf,
55 u8 param_size);
56int ufshcd_query_attr_retry(struct ufs_hba *hba, enum query_opcode opcode,
57 enum attr_idn idn, u8 index, u8 selector,
58 u32 *attr_val);
59int ufshcd_query_attr(struct ufs_hba *hba, enum query_opcode opcode,
60 enum attr_idn idn, u8 index, u8 selector, u32 *attr_val);
61int ufshcd_query_flag(struct ufs_hba *hba, enum query_opcode opcode,
62 enum flag_idn idn, u8 index, bool *flag_res);
63void ufshcd_auto_hibern8_update(struct ufs_hba *hba, u32 ahit);
64void ufshcd_compl_one_cqe(struct ufs_hba *hba, int task_tag,
65 struct cq_entry *cqe);
66int ufshcd_mcq_init(struct ufs_hba *hba);
67void ufshcd_mcq_disable(struct ufs_hba *hba);
68int ufshcd_mcq_decide_queue_depth(struct ufs_hba *hba);
69int ufshcd_mcq_memory_alloc(struct ufs_hba *hba);
70struct ufs_hw_queue *ufshcd_mcq_req_to_hwq(struct ufs_hba *hba,
71 struct request *req);
72void ufshcd_mcq_compl_all_cqes_lock(struct ufs_hba *hba,
73 struct ufs_hw_queue *hwq);
74bool ufshcd_cmd_inflight(struct scsi_cmnd *cmd);
75int ufshcd_mcq_sq_cleanup(struct ufs_hba *hba, int task_tag);
76int ufshcd_mcq_abort(struct scsi_cmnd *cmd);
77int ufshcd_try_to_abort_task(struct ufs_hba *hba, int tag);
78void ufshcd_release_scsi_cmd(struct ufs_hba *hba,
79 struct ufshcd_lrb *lrbp);
80
81#define SD_ASCII_STD true
82#define SD_RAW false
83int ufshcd_read_string_desc(struct ufs_hba *hba, u8 desc_index,
84 u8 **buf, bool ascii);
85
86int ufshcd_send_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd);
87int ufshcd_send_bsg_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd);
88
89int ufshcd_exec_raw_upiu_cmd(struct ufs_hba *hba,
90 struct utp_upiu_req *req_upiu,
91 struct utp_upiu_req *rsp_upiu,
92 enum upiu_request_transaction msgcode,
93 u8 *desc_buff, int *buff_len,
94 enum query_opcode desc_op);
95
96int ufshcd_wb_toggle(struct ufs_hba *hba, bool enable);
97int ufshcd_read_device_lvl_exception_id(struct ufs_hba *hba, u64 *exception_id);
98
99/* Wrapper functions for safely calling variant operations */
100static inline const char *ufshcd_get_var_name(struct ufs_hba *hba)
101{
102 if (hba->vops)
103 return hba->vops->name;
104 return "";
105}
106
107static inline void ufshcd_vops_exit(struct ufs_hba *hba)
108{
109 if (hba->vops && hba->vops->exit)
110 return hba->vops->exit(hba);
111}
112
113static inline u32 ufshcd_vops_get_ufs_hci_version(struct ufs_hba *hba)
114{
115 if (hba->vops && hba->vops->get_ufs_hci_version)
116 return hba->vops->get_ufs_hci_version(hba);
117
118 return ufshcd_readl(hba, REG_UFS_VERSION);
119}
120
121static inline int ufshcd_vops_clk_scale_notify(struct ufs_hba *hba, bool up,
122 unsigned long target_freq,
123 enum ufs_notify_change_status status)
124{
125 if (hba->vops && hba->vops->clk_scale_notify)
126 return hba->vops->clk_scale_notify(hba, up, target_freq, status);
127 return 0;
128}
129
130static inline void ufshcd_vops_event_notify(struct ufs_hba *hba,
131 enum ufs_event_type evt,
132 void *data)
133{
134 if (hba->vops && hba->vops->event_notify)
135 hba->vops->event_notify(hba, evt, data);
136}
137
138static inline int ufshcd_vops_setup_clocks(struct ufs_hba *hba, bool on,
139 enum ufs_notify_change_status status)
140{
141 if (hba->vops && hba->vops->setup_clocks)
142 return hba->vops->setup_clocks(hba, on, status);
143 return 0;
144}
145
146static inline int ufshcd_vops_hce_enable_notify(struct ufs_hba *hba,
147 bool status)
148{
149 if (hba->vops && hba->vops->hce_enable_notify)
150 return hba->vops->hce_enable_notify(hba, status);
151
152 return 0;
153}
154static inline int ufshcd_vops_link_startup_notify(struct ufs_hba *hba,
155 bool status)
156{
157 if (hba->vops && hba->vops->link_startup_notify)
158 return hba->vops->link_startup_notify(hba, status);
159
160 return 0;
161}
162
163static inline int ufshcd_vops_pwr_change_notify(struct ufs_hba *hba,
164 enum ufs_notify_change_status status,
165 const struct ufs_pa_layer_attr *dev_max_params,
166 struct ufs_pa_layer_attr *dev_req_params)
167{
168 if (hba->vops && hba->vops->pwr_change_notify)
169 return hba->vops->pwr_change_notify(hba, status,
170 dev_max_params, dev_req_params);
171
172 return -ENOTSUPP;
173}
174
175static inline void ufshcd_vops_setup_task_mgmt(struct ufs_hba *hba,
176 int tag, u8 tm_function)
177{
178 if (hba->vops && hba->vops->setup_task_mgmt)
179 return hba->vops->setup_task_mgmt(hba, tag, tm_function);
180}
181
182static inline void ufshcd_vops_hibern8_notify(struct ufs_hba *hba,
183 enum uic_cmd_dme cmd,
184 enum ufs_notify_change_status status)
185{
186 if (hba->vops && hba->vops->hibern8_notify)
187 return hba->vops->hibern8_notify(hba, cmd, status);
188}
189
190static inline int ufshcd_vops_apply_dev_quirks(struct ufs_hba *hba)
191{
192 if (hba->vops && hba->vops->apply_dev_quirks)
193 return hba->vops->apply_dev_quirks(hba);
194 return 0;
195}
196
197static inline void ufshcd_vops_fixup_dev_quirks(struct ufs_hba *hba)
198{
199 if (hba->vops && hba->vops->fixup_dev_quirks)
200 hba->vops->fixup_dev_quirks(hba);
201}
202
203static inline int ufshcd_vops_suspend(struct ufs_hba *hba, enum ufs_pm_op op,
204 enum ufs_notify_change_status status)
205{
206 if (hba->vops && hba->vops->suspend)
207 return hba->vops->suspend(hba, op, status);
208
209 return 0;
210}
211
212static inline int ufshcd_vops_resume(struct ufs_hba *hba, enum ufs_pm_op op)
213{
214 if (hba->vops && hba->vops->resume)
215 return hba->vops->resume(hba, op);
216
217 return 0;
218}
219
220static inline void ufshcd_vops_dbg_register_dump(struct ufs_hba *hba)
221{
222 if (hba->vops && hba->vops->dbg_register_dump)
223 hba->vops->dbg_register_dump(hba);
224}
225
226static inline int ufshcd_vops_device_reset(struct ufs_hba *hba)
227{
228 if (hba->vops && hba->vops->device_reset)
229 return hba->vops->device_reset(hba);
230
231 return -EOPNOTSUPP;
232}
233
234static inline void ufshcd_vops_config_scaling_param(struct ufs_hba *hba,
235 struct devfreq_dev_profile *p,
236 struct devfreq_simple_ondemand_data *data)
237{
238 if (hba->vops && hba->vops->config_scaling_param)
239 hba->vops->config_scaling_param(hba, p, data);
240}
241
242static inline int ufshcd_vops_mcq_config_resource(struct ufs_hba *hba)
243{
244 if (hba->vops && hba->vops->mcq_config_resource)
245 return hba->vops->mcq_config_resource(hba);
246
247 return -EOPNOTSUPP;
248}
249
250static inline int ufshcd_mcq_vops_op_runtime_config(struct ufs_hba *hba)
251{
252 if (hba->vops && hba->vops->op_runtime_config)
253 return hba->vops->op_runtime_config(hba);
254
255 return -EOPNOTSUPP;
256}
257
258static inline int ufshcd_vops_get_outstanding_cqs(struct ufs_hba *hba,
259 unsigned long *ocqs)
260{
261 if (hba->vops && hba->vops->get_outstanding_cqs)
262 return hba->vops->get_outstanding_cqs(hba, ocqs);
263
264 return -EOPNOTSUPP;
265}
266
267static inline int ufshcd_mcq_vops_config_esi(struct ufs_hba *hba)
268{
269 if (hba->vops && hba->vops->config_esi)
270 return hba->vops->config_esi(hba);
271
272 return -EOPNOTSUPP;
273}
274
275static inline u32 ufshcd_vops_freq_to_gear_speed(struct ufs_hba *hba, unsigned long freq)
276{
277 if (hba->vops && hba->vops->freq_to_gear_speed)
278 return hba->vops->freq_to_gear_speed(hba, freq);
279
280 return 0;
281}
282
283extern const struct ufs_pm_lvl_states ufs_pm_lvl_states[];
284
285/**
286 * ufshcd_scsi_to_upiu_lun - maps scsi LUN to UPIU LUN
287 * @scsi_lun: scsi LUN id
288 *
289 * Return: UPIU LUN id
290 */
291static inline u8 ufshcd_scsi_to_upiu_lun(unsigned int scsi_lun)
292{
293 if (scsi_is_wlun(lun: scsi_lun))
294 return (scsi_lun & UFS_UPIU_MAX_UNIT_NUM_ID)
295 | UFS_UPIU_WLUN_ID;
296 else
297 return scsi_lun & UFS_UPIU_MAX_UNIT_NUM_ID;
298}
299
300int __ufshcd_write_ee_control(struct ufs_hba *hba, u32 ee_ctrl_mask);
301int ufshcd_write_ee_control(struct ufs_hba *hba);
302int ufshcd_update_ee_control(struct ufs_hba *hba, u16 *mask,
303 const u16 *other_mask, u16 set, u16 clr);
304
305static inline int ufshcd_update_ee_drv_mask(struct ufs_hba *hba,
306 u16 set, u16 clr)
307{
308 return ufshcd_update_ee_control(hba, mask: &hba->ee_drv_mask,
309 other_mask: &hba->ee_usr_mask, set, clr);
310}
311
312static inline int ufshcd_update_ee_usr_mask(struct ufs_hba *hba,
313 u16 set, u16 clr)
314{
315 return ufshcd_update_ee_control(hba, mask: &hba->ee_usr_mask,
316 other_mask: &hba->ee_drv_mask, set, clr);
317}
318
319static inline int ufshcd_rpm_get_sync(struct ufs_hba *hba)
320{
321 return pm_runtime_get_sync(dev: &hba->ufs_device_wlun->sdev_gendev);
322}
323
324static inline int ufshcd_rpm_get_if_active(struct ufs_hba *hba)
325{
326 return pm_runtime_get_if_active(dev: &hba->ufs_device_wlun->sdev_gendev);
327}
328
329static inline int ufshcd_rpm_put_sync(struct ufs_hba *hba)
330{
331 return pm_runtime_put_sync(dev: &hba->ufs_device_wlun->sdev_gendev);
332}
333
334static inline void ufshcd_rpm_get_noresume(struct ufs_hba *hba)
335{
336 pm_runtime_get_noresume(dev: &hba->ufs_device_wlun->sdev_gendev);
337}
338
339static inline int ufshcd_rpm_resume(struct ufs_hba *hba)
340{
341 return pm_runtime_resume(dev: &hba->ufs_device_wlun->sdev_gendev);
342}
343
344static inline int ufshcd_rpm_put(struct ufs_hba *hba)
345{
346 return pm_runtime_put(dev: &hba->ufs_device_wlun->sdev_gendev);
347}
348
349/**
350 * ufs_is_valid_unit_desc_lun - checks if the given LUN has a unit descriptor
351 * @dev_info: pointer of instance of struct ufs_dev_info
352 * @lun: LU number to check
353 * @return: true if the lun has a matching unit descriptor, false otherwise
354 */
355static inline bool ufs_is_valid_unit_desc_lun(struct ufs_dev_info *dev_info, u8 lun)
356{
357 if (!dev_info || !dev_info->max_lu_supported) {
358 pr_err("Max General LU supported by UFS isn't initialized\n");
359 return false;
360 }
361 return lun == UFS_UPIU_RPMB_WLUN || (lun < dev_info->max_lu_supported);
362}
363
364static inline void ufshcd_inc_sq_tail(struct ufs_hw_queue *q)
365 __must_hold(&q->sq_lock)
366{
367 u32 val;
368
369 q->sq_tail_slot++;
370 if (q->sq_tail_slot == q->max_entries)
371 q->sq_tail_slot = 0;
372 val = q->sq_tail_slot * sizeof(struct utp_transfer_req_desc);
373 writel(val, addr: q->mcq_sq_tail);
374}
375
376static inline void ufshcd_mcq_update_cq_tail_slot(struct ufs_hw_queue *q)
377{
378 u32 val = readl(addr: q->mcq_cq_tail);
379
380 q->cq_tail_slot = val / sizeof(struct cq_entry);
381}
382
383static inline bool ufshcd_mcq_is_cq_empty(struct ufs_hw_queue *q)
384{
385 return q->cq_head_slot == q->cq_tail_slot;
386}
387
388static inline void ufshcd_mcq_inc_cq_head_slot(struct ufs_hw_queue *q)
389{
390 q->cq_head_slot++;
391 if (q->cq_head_slot == q->max_entries)
392 q->cq_head_slot = 0;
393}
394
395static inline void ufshcd_mcq_update_cq_head(struct ufs_hw_queue *q)
396{
397 writel(val: q->cq_head_slot * sizeof(struct cq_entry), addr: q->mcq_cq_head);
398}
399
400static inline struct cq_entry *ufshcd_mcq_cur_cqe(struct ufs_hw_queue *q)
401{
402 struct cq_entry *cqe = q->cqe_base_addr;
403
404 return cqe + q->cq_head_slot;
405}
406
407static inline u32 ufshcd_mcq_get_sq_head_slot(struct ufs_hw_queue *q)
408{
409 u32 val = readl(addr: q->mcq_sq_head);
410
411 return val / sizeof(struct utp_transfer_req_desc);
412}
413
414#endif /* _UFSHCD_PRIV_H_ */
415

source code of linux/drivers/ufs/core/ufshcd-priv.h