drivers/ufs/core/ufshcd-priv.h

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