source: src/linux/universal/linux-4.9/drivers/scsi/ufs/ufshcd.h @ 31859

Last change on this file since 31859 was 31859, checked in by brainslayer, 3 months ago

kernel update

File size: 24.9 KB
Line 
1/*
2 * Universal Flash Storage Host controller driver
3 *
4 * This code is based on drivers/scsi/ufs/ufshcd.h
5 * Copyright (C) 2011-2013 Samsung India Software Operations
6 * Copyright (c) 2013-2016, The Linux Foundation. All rights reserved.
7 *
8 * Authors:
9 *      Santosh Yaraganavi <santosh.sy@samsung.com>
10 *      Vinayak Holikatti <h.vinayak@samsung.com>
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
16 * See the COPYING file in the top-level directory or visit
17 * <http://www.gnu.org/licenses/gpl-2.0.html>
18 *
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22 * GNU General Public License for more details.
23 *
24 * This program is provided "AS IS" and "WITH ALL FAULTS" and
25 * without warranty of any kind. You are solely responsible for
26 * determining the appropriateness of using and distributing
27 * the program and assume all risks associated with your exercise
28 * of rights with respect to the program, including but not limited
29 * to infringement of third party rights, the risks and costs of
30 * program errors, damage to or loss of data, programs or equipment,
31 * and unavailability or interruption of operations. Under no
32 * circumstances will the contributor of this Program be liable for
33 * any damages of any kind arising from your use or distribution of
34 * this program.
35 */
36
37#ifndef _UFSHCD_H
38#define _UFSHCD_H
39
40#include <linux/module.h>
41#include <linux/kernel.h>
42#include <linux/init.h>
43#include <linux/interrupt.h>
44#include <linux/io.h>
45#include <linux/delay.h>
46#include <linux/slab.h>
47#include <linux/spinlock.h>
48#include <linux/workqueue.h>
49#include <linux/errno.h>
50#include <linux/types.h>
51#include <linux/wait.h>
52#include <linux/bitops.h>
53#include <linux/pm_runtime.h>
54#include <linux/clk.h>
55#include <linux/completion.h>
56#include <linux/regulator/consumer.h>
57#include "unipro.h"
58
59#include <asm/irq.h>
60#include <asm/byteorder.h>
61#include <scsi/scsi.h>
62#include <scsi/scsi_cmnd.h>
63#include <scsi/scsi_host.h>
64#include <scsi/scsi_tcq.h>
65#include <scsi/scsi_dbg.h>
66#include <scsi/scsi_eh.h>
67
68#include "ufs.h"
69#include "ufshci.h"
70
71#define UFSHCD "ufshcd"
72#define UFSHCD_DRIVER_VERSION "0.2"
73
74struct ufs_hba;
75
76enum dev_cmd_type {
77        DEV_CMD_TYPE_NOP                = 0x0,
78        DEV_CMD_TYPE_QUERY              = 0x1,
79};
80
81/**
82 * struct uic_command - UIC command structure
83 * @command: UIC command
84 * @argument1: UIC command argument 1
85 * @argument2: UIC command argument 2
86 * @argument3: UIC command argument 3
87 * @cmd_active: Indicate if UIC command is outstanding
88 * @result: UIC command result
89 * @done: UIC command completion
90 */
91struct uic_command {
92        u32 command;
93        u32 argument1;
94        u32 argument2;
95        u32 argument3;
96        int cmd_active;
97        int result;
98        struct completion done;
99};
100
101/* Used to differentiate the power management options */
102enum ufs_pm_op {
103        UFS_RUNTIME_PM,
104        UFS_SYSTEM_PM,
105        UFS_SHUTDOWN_PM,
106};
107
108#define ufshcd_is_runtime_pm(op) ((op) == UFS_RUNTIME_PM)
109#define ufshcd_is_system_pm(op) ((op) == UFS_SYSTEM_PM)
110#define ufshcd_is_shutdown_pm(op) ((op) == UFS_SHUTDOWN_PM)
111
112/* Host <-> Device UniPro Link state */
113enum uic_link_state {
114        UIC_LINK_OFF_STATE      = 0, /* Link powered down or disabled */
115        UIC_LINK_ACTIVE_STATE   = 1, /* Link is in Fast/Slow/Sleep state */
116        UIC_LINK_HIBERN8_STATE  = 2, /* Link is in Hibernate state */
117};
118
119#define ufshcd_is_link_off(hba) ((hba)->uic_link_state == UIC_LINK_OFF_STATE)
120#define ufshcd_is_link_active(hba) ((hba)->uic_link_state == \
121                                    UIC_LINK_ACTIVE_STATE)
122#define ufshcd_is_link_hibern8(hba) ((hba)->uic_link_state == \
123                                    UIC_LINK_HIBERN8_STATE)
124#define ufshcd_set_link_off(hba) ((hba)->uic_link_state = UIC_LINK_OFF_STATE)
125#define ufshcd_set_link_active(hba) ((hba)->uic_link_state = \
126                                    UIC_LINK_ACTIVE_STATE)
127#define ufshcd_set_link_hibern8(hba) ((hba)->uic_link_state = \
128                                    UIC_LINK_HIBERN8_STATE)
129
130/*
131 * UFS Power management levels.
132 * Each level is in increasing order of power savings.
133 */
134enum ufs_pm_level {
135        UFS_PM_LVL_0, /* UFS_ACTIVE_PWR_MODE, UIC_LINK_ACTIVE_STATE */
136        UFS_PM_LVL_1, /* UFS_ACTIVE_PWR_MODE, UIC_LINK_HIBERN8_STATE */
137        UFS_PM_LVL_2, /* UFS_SLEEP_PWR_MODE, UIC_LINK_ACTIVE_STATE */
138        UFS_PM_LVL_3, /* UFS_SLEEP_PWR_MODE, UIC_LINK_HIBERN8_STATE */
139        UFS_PM_LVL_4, /* UFS_POWERDOWN_PWR_MODE, UIC_LINK_HIBERN8_STATE */
140        UFS_PM_LVL_5, /* UFS_POWERDOWN_PWR_MODE, UIC_LINK_OFF_STATE */
141        UFS_PM_LVL_MAX
142};
143
144struct ufs_pm_lvl_states {
145        enum ufs_dev_pwr_mode dev_state;
146        enum uic_link_state link_state;
147};
148
149/**
150 * struct ufshcd_lrb - local reference block
151 * @utr_descriptor_ptr: UTRD address of the command
152 * @ucd_req_ptr: UCD address of the command
153 * @ucd_rsp_ptr: Response UPIU address for this command
154 * @ucd_prdt_ptr: PRDT address of the command
155 * @cmd: pointer to SCSI command
156 * @sense_buffer: pointer to sense buffer address of the SCSI command
157 * @sense_bufflen: Length of the sense buffer
158 * @scsi_status: SCSI status of the command
159 * @command_type: SCSI, UFS, Query.
160 * @task_tag: Task tag of the command
161 * @lun: LUN of the command
162 * @intr_cmd: Interrupt command (doesn't participate in interrupt aggregation)
163 */
164struct ufshcd_lrb {
165        struct utp_transfer_req_desc *utr_descriptor_ptr;
166        struct utp_upiu_req *ucd_req_ptr;
167        struct utp_upiu_rsp *ucd_rsp_ptr;
168        struct ufshcd_sg_entry *ucd_prdt_ptr;
169
170        struct scsi_cmnd *cmd;
171        u8 *sense_buffer;
172        unsigned int sense_bufflen;
173        int scsi_status;
174
175        int command_type;
176        int task_tag;
177        u8 lun; /* UPIU LUN id field is only 8-bit wide */
178        bool intr_cmd;
179};
180
181/**
182 * struct ufs_query - holds relevant data structures for query request
183 * @request: request upiu and function
184 * @descriptor: buffer for sending/receiving descriptor
185 * @response: response upiu and response
186 */
187struct ufs_query {
188        struct ufs_query_req request;
189        u8 *descriptor;
190        struct ufs_query_res response;
191};
192
193/**
194 * struct ufs_dev_cmd - all assosiated fields with device management commands
195 * @type: device management command type - Query, NOP OUT
196 * @lock: lock to allow one command at a time
197 * @complete: internal commands completion
198 * @tag_wq: wait queue until free command slot is available
199 */
200struct ufs_dev_cmd {
201        enum dev_cmd_type type;
202        struct mutex lock;
203        struct completion *complete;
204        wait_queue_head_t tag_wq;
205        struct ufs_query query;
206};
207
208/**
209 * struct ufs_clk_info - UFS clock related info
210 * @list: list headed by hba->clk_list_head
211 * @clk: clock node
212 * @name: clock name
213 * @max_freq: maximum frequency supported by the clock
214 * @min_freq: min frequency that can be used for clock scaling
215 * @curr_freq: indicates the current frequency that it is set to
216 * @enabled: variable to check against multiple enable/disable
217 */
218struct ufs_clk_info {
219        struct list_head list;
220        struct clk *clk;
221        const char *name;
222        u32 max_freq;
223        u32 min_freq;
224        u32 curr_freq;
225        bool enabled;
226};
227
228enum ufs_notify_change_status {
229        PRE_CHANGE,
230        POST_CHANGE,
231};
232
233struct ufs_pa_layer_attr {
234        u32 gear_rx;
235        u32 gear_tx;
236        u32 lane_rx;
237        u32 lane_tx;
238        u32 pwr_rx;
239        u32 pwr_tx;
240        u32 hs_rate;
241};
242
243struct ufs_pwr_mode_info {
244        bool is_valid;
245        struct ufs_pa_layer_attr info;
246};
247
248/**
249 * struct ufs_hba_variant_ops - variant specific callbacks
250 * @name: variant name
251 * @init: called when the driver is initialized
252 * @exit: called to cleanup everything done in init
253 * @get_ufs_hci_version: called to get UFS HCI version
254 * @clk_scale_notify: notifies that clks are scaled up/down
255 * @setup_clocks: called before touching any of the controller registers
256 * @setup_regulators: called before accessing the host controller
257 * @hce_enable_notify: called before and after HCE enable bit is set to allow
258 *                     variant specific Uni-Pro initialization.
259 * @link_startup_notify: called before and after Link startup is carried out
260 *                       to allow variant specific Uni-Pro initialization.
261 * @pwr_change_notify: called before and after a power mode change
262 *                      is carried out to allow vendor spesific capabilities
263 *                      to be set.
264 * @apply_dev_quirks: called to apply device specific quirks
265 * @suspend: called during host controller PM callback
266 * @resume: called during host controller PM callback
267 * @dbg_register_dump: used to dump controller debug information
268 * @phy_initialization: used to initialize phys
269 */
270struct ufs_hba_variant_ops {
271        const char *name;
272        int     (*init)(struct ufs_hba *);
273        void    (*exit)(struct ufs_hba *);
274        u32     (*get_ufs_hci_version)(struct ufs_hba *);
275        int     (*clk_scale_notify)(struct ufs_hba *, bool,
276                                    enum ufs_notify_change_status);
277        int     (*setup_clocks)(struct ufs_hba *, bool);
278        int     (*setup_regulators)(struct ufs_hba *, bool);
279        int     (*hce_enable_notify)(struct ufs_hba *,
280                                     enum ufs_notify_change_status);
281        int     (*link_startup_notify)(struct ufs_hba *,
282                                       enum ufs_notify_change_status);
283        int     (*pwr_change_notify)(struct ufs_hba *,
284                                        enum ufs_notify_change_status status,
285                                        struct ufs_pa_layer_attr *,
286                                        struct ufs_pa_layer_attr *);
287        int     (*apply_dev_quirks)(struct ufs_hba *);
288        int     (*suspend)(struct ufs_hba *, enum ufs_pm_op);
289        int     (*resume)(struct ufs_hba *, enum ufs_pm_op);
290        void    (*dbg_register_dump)(struct ufs_hba *hba);
291        int     (*phy_initialization)(struct ufs_hba *);
292};
293
294/* clock gating state  */
295enum clk_gating_state {
296        CLKS_OFF,
297        CLKS_ON,
298        REQ_CLKS_OFF,
299        REQ_CLKS_ON,
300};
301
302/**
303 * struct ufs_clk_gating - UFS clock gating related info
304 * @gate_work: worker to turn off clocks after some delay as specified in
305 * delay_ms
306 * @ungate_work: worker to turn on clocks that will be used in case of
307 * interrupt context
308 * @state: the current clocks state
309 * @delay_ms: gating delay in ms
310 * @is_suspended: clk gating is suspended when set to 1 which can be used
311 * during suspend/resume
312 * @delay_attr: sysfs attribute to control delay_attr
313 * @active_reqs: number of requests that are pending and should be waited for
314 * completion before gating clocks.
315 */
316struct ufs_clk_gating {
317        struct delayed_work gate_work;
318        struct work_struct ungate_work;
319        enum clk_gating_state state;
320        unsigned long delay_ms;
321        bool is_suspended;
322        struct device_attribute delay_attr;
323        int active_reqs;
324};
325
326struct ufs_clk_scaling {
327        ktime_t  busy_start_t;
328        bool is_busy_started;
329        unsigned long  tot_busy_t;
330        unsigned long window_start_t;
331};
332
333/**
334 * struct ufs_init_prefetch - contains data that is pre-fetched once during
335 * initialization
336 * @icc_level: icc level which was read during initialization
337 */
338struct ufs_init_prefetch {
339        u32 icc_level;
340};
341
342/**
343 * struct ufs_hba - per adapter private structure
344 * @mmio_base: UFSHCI base register address
345 * @ucdl_base_addr: UFS Command Descriptor base address
346 * @utrdl_base_addr: UTP Transfer Request Descriptor base address
347 * @utmrdl_base_addr: UTP Task Management Descriptor base address
348 * @ucdl_dma_addr: UFS Command Descriptor DMA address
349 * @utrdl_dma_addr: UTRDL DMA address
350 * @utmrdl_dma_addr: UTMRDL DMA address
351 * @host: Scsi_Host instance of the driver
352 * @dev: device handle
353 * @lrb: local reference block
354 * @lrb_in_use: lrb in use
355 * @outstanding_tasks: Bits representing outstanding task requests
356 * @outstanding_reqs: Bits representing outstanding transfer requests
357 * @capabilities: UFS Controller Capabilities
358 * @nutrs: Transfer Request Queue depth supported by controller
359 * @nutmrs: Task Management Queue depth supported by controller
360 * @ufs_version: UFS Version to which controller complies
361 * @vops: pointer to variant specific operations
362 * @priv: pointer to variant specific private data
363 * @irq: Irq number of the controller
364 * @active_uic_cmd: handle of active UIC command
365 * @uic_cmd_mutex: mutex for uic command
366 * @tm_wq: wait queue for task management
367 * @tm_tag_wq: wait queue for free task management slots
368 * @tm_slots_in_use: bit map of task management request slots in use
369 * @pwr_done: completion for power mode change
370 * @tm_condition: condition variable for task management
371 * @ufshcd_state: UFSHCD states
372 * @eh_flags: Error handling flags
373 * @intr_mask: Interrupt Mask Bits
374 * @ee_ctrl_mask: Exception event control mask
375 * @is_powered: flag to check if HBA is powered
376 * @is_init_prefetch: flag to check if data was pre-fetched in initialization
377 * @init_prefetch_data: data pre-fetched during initialization
378 * @eh_work: Worker to handle UFS errors that require s/w attention
379 * @eeh_work: Worker to handle exception events
380 * @errors: HBA errors
381 * @uic_error: UFS interconnect layer error status
382 * @saved_err: sticky error mask
383 * @saved_uic_err: sticky UIC error mask
384 * @dev_cmd: ufs device management command information
385 * @last_dme_cmd_tstamp: time stamp of the last completed DME command
386 * @auto_bkops_enabled: to track whether bkops is enabled in device
387 * @vreg_info: UFS device voltage regulator information
388 * @clk_list_head: UFS host controller clocks list node head
389 * @pwr_info: holds current power mode
390 * @max_pwr_info: keeps the device max valid pwm
391 * @urgent_bkops_lvl: keeps track of urgent bkops level for device
392 * @is_urgent_bkops_lvl_checked: keeps track if the urgent bkops level for
393 *  device is known or not.
394 */
395struct ufs_hba {
396        void __iomem *mmio_base;
397
398        /* Virtual memory reference */
399        struct utp_transfer_cmd_desc *ucdl_base_addr;
400        struct utp_transfer_req_desc *utrdl_base_addr;
401        struct utp_task_req_desc *utmrdl_base_addr;
402
403        /* DMA memory reference */
404        dma_addr_t ucdl_dma_addr;
405        dma_addr_t utrdl_dma_addr;
406        dma_addr_t utmrdl_dma_addr;
407
408        struct Scsi_Host *host;
409        struct device *dev;
410        /*
411         * This field is to keep a reference to "scsi_device" corresponding to
412         * "UFS device" W-LU.
413         */
414        struct scsi_device *sdev_ufs_device;
415
416        enum ufs_dev_pwr_mode curr_dev_pwr_mode;
417        enum uic_link_state uic_link_state;
418        /* Desired UFS power management level during runtime PM */
419        enum ufs_pm_level rpm_lvl;
420        /* Desired UFS power management level during system PM */
421        enum ufs_pm_level spm_lvl;
422        int pm_op_in_progress;
423
424        struct ufshcd_lrb *lrb;
425        unsigned long lrb_in_use;
426
427        unsigned long outstanding_tasks;
428        unsigned long outstanding_reqs;
429
430        u32 capabilities;
431        int nutrs;
432        int nutmrs;
433        u32 ufs_version;
434        struct ufs_hba_variant_ops *vops;
435        void *priv;
436        unsigned int irq;
437        bool is_irq_enabled;
438
439        /* Interrupt aggregation support is broken */
440        #define UFSHCD_QUIRK_BROKEN_INTR_AGGR                   UFS_BIT(0)
441
442        /*
443         * delay before each dme command is required as the unipro
444         * layer has shown instabilities
445         */
446        #define UFSHCD_QUIRK_DELAY_BEFORE_DME_CMDS              UFS_BIT(1)
447
448        /*
449         * If UFS host controller is having issue in processing LCC (Line
450         * Control Command) coming from device then enable this quirk.
451         * When this quirk is enabled, host controller driver should disable
452         * the LCC transmission on UFS device (by clearing TX_LCC_ENABLE
453         * attribute of device to 0).
454         */
455        #define UFSHCD_QUIRK_BROKEN_LCC                         UFS_BIT(2)
456
457        /*
458         * The attribute PA_RXHSUNTERMCAP specifies whether or not the
459         * inbound Link supports unterminated line in HS mode. Setting this
460         * attribute to 1 fixes moving to HS gear.
461         */
462        #define UFSHCD_QUIRK_BROKEN_PA_RXHSUNTERMCAP            UFS_BIT(3)
463
464        /*
465         * This quirk needs to be enabled if the host contoller only allows
466         * accessing the peer dme attributes in AUTO mode (FAST AUTO or
467         * SLOW AUTO).
468         */
469        #define UFSHCD_QUIRK_DME_PEER_ACCESS_AUTO_MODE          UFS_BIT(4)
470
471        /*
472         * This quirk needs to be enabled if the host contoller doesn't
473         * advertise the correct version in UFS_VER register. If this quirk
474         * is enabled, standard UFS host driver will call the vendor specific
475         * ops (get_ufs_hci_version) to get the correct version.
476         */
477        #define UFSHCD_QUIRK_BROKEN_UFS_HCI_VERSION             UFS_BIT(5)
478
479        /*
480         * This quirk needs to be enabled if the host contoller regards
481         * resolution of the values of PRDTO and PRDTL in UTRD as byte.
482         */
483        #define UFSHCD_QUIRK_PRDT_BYTE_GRAN                     UFS_BIT(7)
484
485        unsigned int quirks;    /* Deviations from standard UFSHCI spec. */
486
487        /* Device deviations from standard UFS device spec. */
488        unsigned int dev_quirks;
489
490        wait_queue_head_t tm_wq;
491        wait_queue_head_t tm_tag_wq;
492        unsigned long tm_condition;
493        unsigned long tm_slots_in_use;
494
495        struct uic_command *active_uic_cmd;
496        struct mutex uic_cmd_mutex;
497        struct completion *uic_async_done;
498
499        u32 ufshcd_state;
500        u32 eh_flags;
501        u32 intr_mask;
502        u16 ee_ctrl_mask;
503        bool is_powered;
504        bool is_init_prefetch;
505        struct ufs_init_prefetch init_prefetch_data;
506
507        /* Work Queues */
508        struct work_struct eh_work;
509        struct work_struct eeh_work;
510
511        /* HBA Errors */
512        u32 errors;
513        u32 uic_error;
514        u32 saved_err;
515        u32 saved_uic_err;
516
517        /* Device management request data */
518        struct ufs_dev_cmd dev_cmd;
519        ktime_t last_dme_cmd_tstamp;
520
521        /* Keeps information of the UFS device connected to this host */
522        struct ufs_dev_info dev_info;
523        bool auto_bkops_enabled;
524        struct ufs_vreg_info vreg_info;
525        struct list_head clk_list_head;
526
527        bool wlun_dev_clr_ua;
528
529        /* Number of lanes available (1 or 2) for Rx/Tx */
530        u32 lanes_per_direction;
531        struct ufs_pa_layer_attr pwr_info;
532        struct ufs_pwr_mode_info max_pwr_info;
533
534        struct ufs_clk_gating clk_gating;
535        /* Control to enable/disable host capabilities */
536        u32 caps;
537        /* Allow dynamic clk gating */
538#define UFSHCD_CAP_CLK_GATING   (1 << 0)
539        /* Allow hiberb8 with clk gating */
540#define UFSHCD_CAP_HIBERN8_WITH_CLK_GATING (1 << 1)
541        /* Allow dynamic clk scaling */
542#define UFSHCD_CAP_CLK_SCALING  (1 << 2)
543        /* Allow auto bkops to enabled during runtime suspend */
544#define UFSHCD_CAP_AUTO_BKOPS_SUSPEND (1 << 3)
545        /*
546         * This capability allows host controller driver to use the UFS HCI's
547         * interrupt aggregation capability.
548         * CAUTION: Enabling this might reduce overall UFS throughput.
549         */
550#define UFSHCD_CAP_INTR_AGGR (1 << 4)
551
552        struct devfreq *devfreq;
553        struct ufs_clk_scaling clk_scaling;
554        bool is_sys_suspended;
555
556        enum bkops_status urgent_bkops_lvl;
557        bool is_urgent_bkops_lvl_checked;
558};
559
560/* Returns true if clocks can be gated. Otherwise false */
561static inline bool ufshcd_is_clkgating_allowed(struct ufs_hba *hba)
562{
563        return hba->caps & UFSHCD_CAP_CLK_GATING;
564}
565static inline bool ufshcd_can_hibern8_during_gating(struct ufs_hba *hba)
566{
567        return hba->caps & UFSHCD_CAP_HIBERN8_WITH_CLK_GATING;
568}
569static inline int ufshcd_is_clkscaling_enabled(struct ufs_hba *hba)
570{
571        return hba->caps & UFSHCD_CAP_CLK_SCALING;
572}
573static inline bool ufshcd_can_autobkops_during_suspend(struct ufs_hba *hba)
574{
575        return hba->caps & UFSHCD_CAP_AUTO_BKOPS_SUSPEND;
576}
577
578static inline bool ufshcd_is_intr_aggr_allowed(struct ufs_hba *hba)
579{
580/* DWC UFS Core has the Interrupt aggregation feature but is not detectable*/
581#ifndef CONFIG_SCSI_UFS_DWC
582        if ((hba->caps & UFSHCD_CAP_INTR_AGGR) &&
583            !(hba->quirks & UFSHCD_QUIRK_BROKEN_INTR_AGGR))
584                return true;
585        else
586                return false;
587#else
588return true;
589#endif
590}
591
592#define ufshcd_writel(hba, val, reg)    \
593        writel((val), (hba)->mmio_base + (reg))
594#define ufshcd_readl(hba, reg)  \
595        readl((hba)->mmio_base + (reg))
596
597/**
598 * ufshcd_rmwl - read modify write into a register
599 * @hba - per adapter instance
600 * @mask - mask to apply on read value
601 * @val - actual value to write
602 * @reg - register address
603 */
604static inline void ufshcd_rmwl(struct ufs_hba *hba, u32 mask, u32 val, u32 reg)
605{
606        u32 tmp;
607
608        tmp = ufshcd_readl(hba, reg);
609        tmp &= ~mask;
610        tmp |= (val & mask);
611        ufshcd_writel(hba, tmp, reg);
612}
613
614int ufshcd_alloc_host(struct device *, struct ufs_hba **);
615void ufshcd_dealloc_host(struct ufs_hba *);
616int ufshcd_init(struct ufs_hba * , void __iomem * , unsigned int);
617void ufshcd_remove(struct ufs_hba *);
618int ufshcd_wait_for_register(struct ufs_hba *hba, u32 reg, u32 mask,
619                                u32 val, unsigned long interval_us,
620                                unsigned long timeout_ms, bool can_sleep);
621
622static inline void check_upiu_size(void)
623{
624        BUILD_BUG_ON(ALIGNED_UPIU_SIZE <
625                GENERAL_UPIU_REQUEST_SIZE + QUERY_DESC_MAX_SIZE);
626}
627
628/**
629 * ufshcd_set_variant - set variant specific data to the hba
630 * @hba - per adapter instance
631 * @variant - pointer to variant specific data
632 */
633static inline void ufshcd_set_variant(struct ufs_hba *hba, void *variant)
634{
635        BUG_ON(!hba);
636        hba->priv = variant;
637}
638
639/**
640 * ufshcd_get_variant - get variant specific data from the hba
641 * @hba - per adapter instance
642 */
643static inline void *ufshcd_get_variant(struct ufs_hba *hba)
644{
645        BUG_ON(!hba);
646        return hba->priv;
647}
648
649extern int ufshcd_runtime_suspend(struct ufs_hba *hba);
650extern int ufshcd_runtime_resume(struct ufs_hba *hba);
651extern int ufshcd_runtime_idle(struct ufs_hba *hba);
652extern int ufshcd_system_suspend(struct ufs_hba *hba);
653extern int ufshcd_system_resume(struct ufs_hba *hba);
654extern int ufshcd_shutdown(struct ufs_hba *hba);
655extern int ufshcd_dme_set_attr(struct ufs_hba *hba, u32 attr_sel,
656                               u8 attr_set, u32 mib_val, u8 peer);
657extern int ufshcd_dme_get_attr(struct ufs_hba *hba, u32 attr_sel,
658                               u32 *mib_val, u8 peer);
659
660/* UIC command interfaces for DME primitives */
661#define DME_LOCAL       0
662#define DME_PEER        1
663#define ATTR_SET_NOR    0       /* NORMAL */
664#define ATTR_SET_ST     1       /* STATIC */
665
666static inline int ufshcd_dme_set(struct ufs_hba *hba, u32 attr_sel,
667                                 u32 mib_val)
668{
669        return ufshcd_dme_set_attr(hba, attr_sel, ATTR_SET_NOR,
670                                   mib_val, DME_LOCAL);
671}
672
673static inline int ufshcd_dme_st_set(struct ufs_hba *hba, u32 attr_sel,
674                                    u32 mib_val)
675{
676        return ufshcd_dme_set_attr(hba, attr_sel, ATTR_SET_ST,
677                                   mib_val, DME_LOCAL);
678}
679
680static inline int ufshcd_dme_peer_set(struct ufs_hba *hba, u32 attr_sel,
681                                      u32 mib_val)
682{
683        return ufshcd_dme_set_attr(hba, attr_sel, ATTR_SET_NOR,
684                                   mib_val, DME_PEER);
685}
686
687static inline int ufshcd_dme_peer_st_set(struct ufs_hba *hba, u32 attr_sel,
688                                         u32 mib_val)
689{
690        return ufshcd_dme_set_attr(hba, attr_sel, ATTR_SET_ST,
691                                   mib_val, DME_PEER);
692}
693
694static inline int ufshcd_dme_get(struct ufs_hba *hba,
695                                 u32 attr_sel, u32 *mib_val)
696{
697        return ufshcd_dme_get_attr(hba, attr_sel, mib_val, DME_LOCAL);
698}
699
700static inline int ufshcd_dme_peer_get(struct ufs_hba *hba,
701                                      u32 attr_sel, u32 *mib_val)
702{
703        return ufshcd_dme_get_attr(hba, attr_sel, mib_val, DME_PEER);
704}
705
706int ufshcd_read_device_desc(struct ufs_hba *hba, u8 *buf, u32 size);
707
708static inline bool ufshcd_is_hs_mode(struct ufs_pa_layer_attr *pwr_info)
709{
710        return (pwr_info->pwr_rx == FAST_MODE ||
711                pwr_info->pwr_rx == FASTAUTO_MODE) &&
712                (pwr_info->pwr_tx == FAST_MODE ||
713                pwr_info->pwr_tx == FASTAUTO_MODE);
714}
715
716#define ASCII_STD true
717
718int ufshcd_read_string_desc(struct ufs_hba *hba, int desc_index, u8 *buf,
719                                u32 size, bool ascii);
720
721/* Expose Query-Request API */
722int ufshcd_query_flag(struct ufs_hba *hba, enum query_opcode opcode,
723        enum flag_idn idn, bool *flag_res);
724int ufshcd_hold(struct ufs_hba *hba, bool async);
725void ufshcd_release(struct ufs_hba *hba);
726u32 ufshcd_get_local_unipro_ver(struct ufs_hba *hba);
727
728/* Wrapper functions for safely calling variant operations */
729static inline const char *ufshcd_get_var_name(struct ufs_hba *hba)
730{
731        if (hba->vops)
732                return hba->vops->name;
733        return "";
734}
735
736static inline int ufshcd_vops_init(struct ufs_hba *hba)
737{
738        if (hba->vops && hba->vops->init)
739                return hba->vops->init(hba);
740
741        return 0;
742}
743
744static inline void ufshcd_vops_exit(struct ufs_hba *hba)
745{
746        if (hba->vops && hba->vops->exit)
747                return hba->vops->exit(hba);
748}
749
750static inline u32 ufshcd_vops_get_ufs_hci_version(struct ufs_hba *hba)
751{
752        if (hba->vops && hba->vops->get_ufs_hci_version)
753                return hba->vops->get_ufs_hci_version(hba);
754
755        return ufshcd_readl(hba, REG_UFS_VERSION);
756}
757
758static inline int ufshcd_vops_clk_scale_notify(struct ufs_hba *hba,
759                        bool up, enum ufs_notify_change_status status)
760{
761        if (hba->vops && hba->vops->clk_scale_notify)
762                return hba->vops->clk_scale_notify(hba, up, status);
763        return 0;
764}
765
766static inline int ufshcd_vops_setup_clocks(struct ufs_hba *hba, bool on)
767{
768        if (hba->vops && hba->vops->setup_clocks)
769                return hba->vops->setup_clocks(hba, on);
770        return 0;
771}
772
773static inline int ufshcd_vops_setup_regulators(struct ufs_hba *hba, bool status)
774{
775        if (hba->vops && hba->vops->setup_regulators)
776                return hba->vops->setup_regulators(hba, status);
777
778        return 0;
779}
780
781static inline int ufshcd_vops_hce_enable_notify(struct ufs_hba *hba,
782                                                bool status)
783{
784        if (hba->vops && hba->vops->hce_enable_notify)
785                return hba->vops->hce_enable_notify(hba, status);
786
787        return 0;
788}
789static inline int ufshcd_vops_link_startup_notify(struct ufs_hba *hba,
790                                                bool status)
791{
792        if (hba->vops && hba->vops->link_startup_notify)
793                return hba->vops->link_startup_notify(hba, status);
794
795        return 0;
796}
797
798static inline int ufshcd_vops_pwr_change_notify(struct ufs_hba *hba,
799                                  bool status,
800                                  struct ufs_pa_layer_attr *dev_max_params,
801                                  struct ufs_pa_layer_attr *dev_req_params)
802{
803        if (hba->vops && hba->vops->pwr_change_notify)
804                return hba->vops->pwr_change_notify(hba, status,
805                                        dev_max_params, dev_req_params);
806
807        return -ENOTSUPP;
808}
809
810static inline int ufshcd_vops_apply_dev_quirks(struct ufs_hba *hba)
811{
812        if (hba->vops && hba->vops->apply_dev_quirks)
813                return hba->vops->apply_dev_quirks(hba);
814        return 0;
815}
816
817static inline int ufshcd_vops_suspend(struct ufs_hba *hba, enum ufs_pm_op op)
818{
819        if (hba->vops && hba->vops->suspend)
820                return hba->vops->suspend(hba, op);
821
822        return 0;
823}
824
825static inline int ufshcd_vops_resume(struct ufs_hba *hba, enum ufs_pm_op op)
826{
827        if (hba->vops && hba->vops->resume)
828                return hba->vops->resume(hba, op);
829
830        return 0;
831}
832
833static inline void ufshcd_vops_dbg_register_dump(struct ufs_hba *hba)
834{
835        if (hba->vops && hba->vops->dbg_register_dump)
836                hba->vops->dbg_register_dump(hba);
837}
838
839#endif /* End of Header */
Note: See TracBrowser for help on using the repository browser.