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);
67int ufshcd_mcq_decide_queue_depth(struct ufs_hba *hba);
68int ufshcd_mcq_memory_alloc(struct ufs_hba *hba);
69void ufshcd_mcq_make_queues_operational(struct ufs_hba *hba);
70void ufshcd_mcq_config_mac(struct ufs_hba *hba, u32 max_active_cmds);
71u32 ufshcd_mcq_read_cqis(struct ufs_hba *hba, int i);
72void ufshcd_mcq_write_cqis(struct ufs_hba *hba, u32 val, int i);
73struct ufs_hw_queue *ufshcd_mcq_req_to_hwq(struct ufs_hba *hba,
74					   struct request *req);
75unsigned long ufshcd_mcq_poll_cqe_lock(struct ufs_hba *hba,
76				       struct ufs_hw_queue *hwq);
77void ufshcd_mcq_compl_all_cqes_lock(struct ufs_hba *hba,
78				    struct ufs_hw_queue *hwq);
79bool ufshcd_cmd_inflight(struct scsi_cmnd *cmd);
80int ufshcd_mcq_sq_cleanup(struct ufs_hba *hba, int task_tag);
81int ufshcd_mcq_abort(struct scsi_cmnd *cmd);
82int ufshcd_try_to_abort_task(struct ufs_hba *hba, int tag);
83void ufshcd_release_scsi_cmd(struct ufs_hba *hba,
84			     struct ufshcd_lrb *lrbp);
85
86#define SD_ASCII_STD true
87#define SD_RAW false
88int ufshcd_read_string_desc(struct ufs_hba *hba, u8 desc_index,
89			    u8 **buf, bool ascii);
90
91int ufshcd_send_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd);
92
93int ufshcd_exec_raw_upiu_cmd(struct ufs_hba *hba,
94			     struct utp_upiu_req *req_upiu,
95			     struct utp_upiu_req *rsp_upiu,
96			     enum upiu_request_transaction msgcode,
97			     u8 *desc_buff, int *buff_len,
98			     enum query_opcode desc_op);
99
100int ufshcd_wb_toggle(struct ufs_hba *hba, bool enable);
101
102/* Wrapper functions for safely calling variant operations */
103static inline const char *ufshcd_get_var_name(struct ufs_hba *hba)
104{
105	if (hba->vops)
106		return hba->vops->name;
107	return "";
108}
109
110static inline void ufshcd_vops_exit(struct ufs_hba *hba)
111{
112	if (hba->vops && hba->vops->exit)
113		return hba->vops->exit(hba);
114}
115
116static inline u32 ufshcd_vops_get_ufs_hci_version(struct ufs_hba *hba)
117{
118	if (hba->vops && hba->vops->get_ufs_hci_version)
119		return hba->vops->get_ufs_hci_version(hba);
120
121	return ufshcd_readl(hba, REG_UFS_VERSION);
122}
123
124static inline int ufshcd_vops_clk_scale_notify(struct ufs_hba *hba,
125			bool up, enum ufs_notify_change_status status)
126{
127	if (hba->vops && hba->vops->clk_scale_notify)
128		return hba->vops->clk_scale_notify(hba, up, status);
129	return 0;
130}
131
132static inline void ufshcd_vops_event_notify(struct ufs_hba *hba,
133					    enum ufs_event_type evt,
134					    void *data)
135{
136	if (hba->vops && hba->vops->event_notify)
137		hba->vops->event_notify(hba, evt, data);
138}
139
140static inline int ufshcd_vops_setup_clocks(struct ufs_hba *hba, bool on,
141					enum ufs_notify_change_status status)
142{
143	if (hba->vops && hba->vops->setup_clocks)
144		return hba->vops->setup_clocks(hba, on, status);
145	return 0;
146}
147
148static inline int ufshcd_vops_hce_enable_notify(struct ufs_hba *hba,
149						bool status)
150{
151	if (hba->vops && hba->vops->hce_enable_notify)
152		return hba->vops->hce_enable_notify(hba, status);
153
154	return 0;
155}
156static inline int ufshcd_vops_link_startup_notify(struct ufs_hba *hba,
157						bool status)
158{
159	if (hba->vops && hba->vops->link_startup_notify)
160		return hba->vops->link_startup_notify(hba, status);
161
162	return 0;
163}
164
165static inline int ufshcd_vops_pwr_change_notify(struct ufs_hba *hba,
166				  enum ufs_notify_change_status status,
167				  struct ufs_pa_layer_attr *dev_max_params,
168				  struct ufs_pa_layer_attr *dev_req_params)
169{
170	if (hba->vops && hba->vops->pwr_change_notify)
171		return hba->vops->pwr_change_notify(hba, status,
172					dev_max_params, dev_req_params);
173
174	return -ENOTSUPP;
175}
176
177static inline void ufshcd_vops_setup_task_mgmt(struct ufs_hba *hba,
178					int tag, u8 tm_function)
179{
180	if (hba->vops && hba->vops->setup_task_mgmt)
181		return hba->vops->setup_task_mgmt(hba, tag, tm_function);
182}
183
184static inline void ufshcd_vops_hibern8_notify(struct ufs_hba *hba,
185					enum uic_cmd_dme cmd,
186					enum ufs_notify_change_status status)
187{
188	if (hba->vops && hba->vops->hibern8_notify)
189		return hba->vops->hibern8_notify(hba, cmd, status);
190}
191
192static inline int ufshcd_vops_apply_dev_quirks(struct ufs_hba *hba)
193{
194	if (hba->vops && hba->vops->apply_dev_quirks)
195		return hba->vops->apply_dev_quirks(hba);
196	return 0;
197}
198
199static inline void ufshcd_vops_fixup_dev_quirks(struct ufs_hba *hba)
200{
201	if (hba->vops && hba->vops->fixup_dev_quirks)
202		hba->vops->fixup_dev_quirks(hba);
203}
204
205static inline int ufshcd_vops_suspend(struct ufs_hba *hba, enum ufs_pm_op op,
206				enum ufs_notify_change_status status)
207{
208	if (hba->vops && hba->vops->suspend)
209		return hba->vops->suspend(hba, op, status);
210
211	return 0;
212}
213
214static inline int ufshcd_vops_resume(struct ufs_hba *hba, enum ufs_pm_op op)
215{
216	if (hba->vops && hba->vops->resume)
217		return hba->vops->resume(hba, op);
218
219	return 0;
220}
221
222static inline void ufshcd_vops_dbg_register_dump(struct ufs_hba *hba)
223{
224	if (hba->vops && hba->vops->dbg_register_dump)
225		hba->vops->dbg_register_dump(hba);
226}
227
228static inline int ufshcd_vops_device_reset(struct ufs_hba *hba)
229{
230	if (hba->vops && hba->vops->device_reset)
231		return hba->vops->device_reset(hba);
232
233	return -EOPNOTSUPP;
234}
235
236static inline void ufshcd_vops_config_scaling_param(struct ufs_hba *hba,
237		struct devfreq_dev_profile *p,
238		struct devfreq_simple_ondemand_data *data)
239{
240	if (hba->vops && hba->vops->config_scaling_param)
241		hba->vops->config_scaling_param(hba, p, data);
242}
243
244static inline void ufshcd_vops_reinit_notify(struct ufs_hba *hba)
245{
246	if (hba->vops && hba->vops->reinit_notify)
247		hba->vops->reinit_notify(hba);
248}
249
250static inline int ufshcd_vops_mcq_config_resource(struct ufs_hba *hba)
251{
252	if (hba->vops && hba->vops->mcq_config_resource)
253		return hba->vops->mcq_config_resource(hba);
254
255	return -EOPNOTSUPP;
256}
257
258static inline int ufshcd_mcq_vops_get_hba_mac(struct ufs_hba *hba)
259{
260	if (hba->vops && hba->vops->get_hba_mac)
261		return hba->vops->get_hba_mac(hba);
262
263	return -EOPNOTSUPP;
264}
265
266static inline int ufshcd_mcq_vops_op_runtime_config(struct ufs_hba *hba)
267{
268	if (hba->vops && hba->vops->op_runtime_config)
269		return hba->vops->op_runtime_config(hba);
270
271	return -EOPNOTSUPP;
272}
273
274static inline int ufshcd_vops_get_outstanding_cqs(struct ufs_hba *hba,
275						  unsigned long *ocqs)
276{
277	if (hba->vops && hba->vops->get_outstanding_cqs)
278		return hba->vops->get_outstanding_cqs(hba, ocqs);
279
280	return -EOPNOTSUPP;
281}
282
283static inline int ufshcd_mcq_vops_config_esi(struct ufs_hba *hba)
284{
285	if (hba->vops && hba->vops->config_esi)
286		return hba->vops->config_esi(hba);
287
288	return -EOPNOTSUPP;
289}
290
291extern const struct ufs_pm_lvl_states ufs_pm_lvl_states[];
292
293/**
294 * ufshcd_scsi_to_upiu_lun - maps scsi LUN to UPIU LUN
295 * @scsi_lun: scsi LUN id
296 *
297 * Return: UPIU LUN id
298 */
299static inline u8 ufshcd_scsi_to_upiu_lun(unsigned int scsi_lun)
300{
301	if (scsi_is_wlun(scsi_lun))
302		return (scsi_lun & UFS_UPIU_MAX_UNIT_NUM_ID)
303			| UFS_UPIU_WLUN_ID;
304	else
305		return scsi_lun & UFS_UPIU_MAX_UNIT_NUM_ID;
306}
307
308int __ufshcd_write_ee_control(struct ufs_hba *hba, u32 ee_ctrl_mask);
309int ufshcd_write_ee_control(struct ufs_hba *hba);
310int ufshcd_update_ee_control(struct ufs_hba *hba, u16 *mask,
311			     const u16 *other_mask, u16 set, u16 clr);
312
313static inline int ufshcd_update_ee_drv_mask(struct ufs_hba *hba,
314					    u16 set, u16 clr)
315{
316	return ufshcd_update_ee_control(hba, &hba->ee_drv_mask,
317					&hba->ee_usr_mask, set, clr);
318}
319
320static inline int ufshcd_update_ee_usr_mask(struct ufs_hba *hba,
321					    u16 set, u16 clr)
322{
323	return ufshcd_update_ee_control(hba, &hba->ee_usr_mask,
324					&hba->ee_drv_mask, set, clr);
325}
326
327static inline int ufshcd_rpm_get_sync(struct ufs_hba *hba)
328{
329	return pm_runtime_get_sync(&hba->ufs_device_wlun->sdev_gendev);
330}
331
332static inline int ufshcd_rpm_put_sync(struct ufs_hba *hba)
333{
334	return pm_runtime_put_sync(&hba->ufs_device_wlun->sdev_gendev);
335}
336
337static inline void ufshcd_rpm_get_noresume(struct ufs_hba *hba)
338{
339	pm_runtime_get_noresume(&hba->ufs_device_wlun->sdev_gendev);
340}
341
342static inline int ufshcd_rpm_resume(struct ufs_hba *hba)
343{
344	return pm_runtime_resume(&hba->ufs_device_wlun->sdev_gendev);
345}
346
347static inline int ufshcd_rpm_put(struct ufs_hba *hba)
348{
349	return pm_runtime_put(&hba->ufs_device_wlun->sdev_gendev);
350}
351
352/**
353 * ufs_is_valid_unit_desc_lun - checks if the given LUN has a unit descriptor
354 * @dev_info: pointer of instance of struct ufs_dev_info
355 * @lun: LU number to check
356 * @return: true if the lun has a matching unit descriptor, false otherwise
357 */
358static inline bool ufs_is_valid_unit_desc_lun(struct ufs_dev_info *dev_info, u8 lun)
359{
360	if (!dev_info || !dev_info->max_lu_supported) {
361		pr_err("Max General LU supported by UFS isn't initialized\n");
362		return false;
363	}
364	return lun == UFS_UPIU_RPMB_WLUN || (lun < dev_info->max_lu_supported);
365}
366
367static inline void ufshcd_inc_sq_tail(struct ufs_hw_queue *q)
368	__must_hold(&q->sq_lock)
369{
370	u32 val;
371
372	q->sq_tail_slot++;
373	if (q->sq_tail_slot == q->max_entries)
374		q->sq_tail_slot = 0;
375	val = q->sq_tail_slot * sizeof(struct utp_transfer_req_desc);
376	writel(val, q->mcq_sq_tail);
377}
378
379static inline void ufshcd_mcq_update_cq_tail_slot(struct ufs_hw_queue *q)
380{
381	u32 val = readl(q->mcq_cq_tail);
382
383	q->cq_tail_slot = val / sizeof(struct cq_entry);
384}
385
386static inline bool ufshcd_mcq_is_cq_empty(struct ufs_hw_queue *q)
387{
388	return q->cq_head_slot == q->cq_tail_slot;
389}
390
391static inline void ufshcd_mcq_inc_cq_head_slot(struct ufs_hw_queue *q)
392{
393	q->cq_head_slot++;
394	if (q->cq_head_slot == q->max_entries)
395		q->cq_head_slot = 0;
396}
397
398static inline void ufshcd_mcq_update_cq_head(struct ufs_hw_queue *q)
399{
400	writel(q->cq_head_slot * sizeof(struct cq_entry), q->mcq_cq_head);
401}
402
403static inline struct cq_entry *ufshcd_mcq_cur_cqe(struct ufs_hw_queue *q)
404{
405	struct cq_entry *cqe = q->cqe_base_addr;
406
407	return cqe + q->cq_head_slot;
408}
409
410static inline u32 ufshcd_mcq_get_sq_head_slot(struct ufs_hw_queue *q)
411{
412	u32 val = readl(q->mcq_sq_head);
413
414	return val / sizeof(struct utp_transfer_req_desc);
415}
416
417#endif /* _UFSHCD_PRIV_H_ */
418