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 int ufshcd_mcq_decide_queue_depth(struct ufs_hba *hba);
  68 int ufshcd_mcq_memory_alloc(struct ufs_hba *hba);
  69 void ufshcd_mcq_make_queues_operational(struct ufs_hba *hba);
  70 void ufshcd_mcq_config_mac(struct ufs_hba *hba, u32 max_active_cmds);
  71 u32 ufshcd_mcq_read_cqis(struct ufs_hba *hba, int i);
  72 void ufshcd_mcq_write_cqis(struct ufs_hba *hba, u32 val, int i);
  73 struct ufs_hw_queue *ufshcd_mcq_req_to_hwq(struct ufs_hba *hba,
  74                                            struct request *req);
  75 unsigned long ufshcd_mcq_poll_cqe_lock(struct ufs_hba *hba,
  76                                        struct ufs_hw_queue *hwq);
  77 void ufshcd_mcq_compl_all_cqes_lock(struct ufs_hba *hba,
  78                                     struct ufs_hw_queue *hwq);
  79 bool ufshcd_cmd_inflight(struct scsi_cmnd *cmd);
  80 int ufshcd_mcq_sq_cleanup(struct ufs_hba *hba, int task_tag);
  81 int ufshcd_mcq_abort(struct scsi_cmnd *cmd);
  82 int ufshcd_try_to_abort_task(struct ufs_hba *hba, int tag);
  83 void 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
  88 int ufshcd_read_string_desc(struct ufs_hba *hba, u8 desc_index,
  89                             u8 **buf, bool ascii);
  90
  91 int ufshcd_send_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd);
  92
  93 int 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
 100 int ufshcd_wb_toggle(struct ufs_hba *hba, bool enable);
 101
 102 /* Wrapper functions for safely calling variant operations */
 103 static 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
 110 static 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
 116 static 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
 124 static 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
 132 static 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
 140 static 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
 148 static 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 }
 156 static 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
 165 static 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
 177 static 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
 184 static 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
 192 static 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
 199 static 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
 205 static 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
 214 static 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
 222 static 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
 228 static 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
 236 static 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
 244 static 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
 250 static 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
 258 static 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
 266 static 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
 274 static 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
 283 static 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
 291 extern 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  */
 299 static 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
 308 int __ufshcd_write_ee_control(struct ufs_hba *hba, u32 ee_ctrl_mask);
 309 int ufshcd_write_ee_control(struct ufs_hba *hba);
 310 int ufshcd_update_ee_control(struct ufs_hba *hba, u16 *mask,
 311                              const u16 *other_mask, u16 set, u16 clr);
 312
 313 static 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
 320 static 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
 327 static 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
 332 static 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
 337 static inline void ufshcd_rpm_get_noresume(struct ufs_hba *hba)
 338 {
 339         pm_runtime_get_noresume(&hba->ufs_device_wlun->sdev_gendev);
 340 }
 341
 342 static inline int ufshcd_rpm_resume(struct ufs_hba *hba)
 343 {
 344         return pm_runtime_resume(&hba->ufs_device_wlun->sdev_gendev);
 345 }
 346
 347 static 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  */
 358 static 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
 367 static 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
 379 static 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
 386 static 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
 391 static 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
 398 static 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
 403 static 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
 410 static 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_ */