drivers/misc/mei/mei_dev.h

   1 /*
   2  *
   3  * Intel Management Engine Interface (Intel MEI) Linux driver
   4  * Copyright (c) 2003-2012, Intel Corporation.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  */
  16
  17 #ifndef _MEI_DEV_H_
  18 #define _MEI_DEV_H_
  19
  20 #include <linux/types.h>
  21 #include <linux/watchdog.h>
  22 #include <linux/mei.h>
  23 #include "hw.h"
  24
  25 /*
  26  * watch dog definition
  27  */
  28 #define MEI_WD_HDR_SIZE       4
  29 #define MEI_WD_STOP_MSG_SIZE  MEI_WD_HDR_SIZE
  30 #define MEI_WD_START_MSG_SIZE (MEI_WD_HDR_SIZE + 16)
  31
  32 #define MEI_WD_DEFAULT_TIMEOUT   120  /* seconds */
  33 #define MEI_WD_MIN_TIMEOUT       120  /* seconds */
  34 #define MEI_WD_MAX_TIMEOUT     65535  /* seconds */
  35
  36 #define MEI_WD_STOP_TIMEOUT      10 /* msecs */
  37
  38 #define MEI_WD_STATE_INDEPENDENCE_MSG_SENT       (1 << 0)
  39
  40 #define MEI_RD_MSG_BUF_SIZE           (128 * sizeof(u32))
  41
  42
  43 /*
  44  * AMTHI Client UUID
  45  */
  46 extern const uuid_le mei_amthi_guid;
  47
  48 /*
  49  * Watchdog Client UUID
  50  */
  51 extern const uuid_le mei_wd_guid;
  52
  53 /*
  54  * Watchdog independence state message
  55  */
  56 extern const u8 mei_wd_state_independence_msg[3][4];
  57
  58 /*
  59  * Number of Maximum MEI Clients
  60  */
  61 #define MEI_CLIENTS_MAX 256
  62
  63 /*
  64  * Number of File descriptors/handles
  65  * that can be opened to the driver.
  66  *
  67  * Limit to 253: 256 Total Clients
  68  * minus internal client for MEI Bus Messags
  69  * minus internal client for AMTHI
  70  * minus internal client for Watchdog
  71  */
  72 #define  MEI_MAX_OPEN_HANDLE_COUNT (MEI_CLIENTS_MAX - 3)
  73
  74
  75 /* File state */
  76 enum file_state {
  77         MEI_FILE_INITIALIZING = 0,
  78         MEI_FILE_CONNECTING,
  79         MEI_FILE_CONNECTED,
  80         MEI_FILE_DISCONNECTING,
  81         MEI_FILE_DISCONNECTED
  82 };
  83
  84 /* MEI device states */
  85 enum mei_dev_state {
  86         MEI_DEV_INITIALIZING = 0,
  87         MEI_DEV_INIT_CLIENTS,
  88         MEI_DEV_ENABLED,
  89         MEI_DEV_RESETING,
  90         MEI_DEV_DISABLED,
  91         MEI_DEV_RECOVERING_FROM_RESET,
  92         MEI_DEV_POWER_DOWN,
  93         MEI_DEV_POWER_UP
  94 };
  95
  96 const char *mei_dev_state_str(int state);
  97
  98 /* init clients states*/
  99 enum mei_init_clients_states {
 100         MEI_START_MESSAGE = 0,
 101         MEI_ENUM_CLIENTS_MESSAGE,
 102         MEI_CLIENT_PROPERTIES_MESSAGE
 103 };
 104
 105 enum iamthif_states {
 106         MEI_IAMTHIF_IDLE,
 107         MEI_IAMTHIF_WRITING,
 108         MEI_IAMTHIF_FLOW_CONTROL,
 109         MEI_IAMTHIF_READING,
 110         MEI_IAMTHIF_READ_COMPLETE
 111 };
 112
 113 enum mei_file_transaction_states {
 114         MEI_IDLE,
 115         MEI_WRITING,
 116         MEI_WRITE_COMPLETE,
 117         MEI_FLOW_CONTROL,
 118         MEI_READING,
 119         MEI_READ_COMPLETE
 120 };
 121
 122 enum mei_wd_states {
 123         MEI_WD_IDLE,
 124         MEI_WD_RUNNING,
 125         MEI_WD_STOPPING,
 126 };
 127
 128 /* MEI CB */
 129 enum mei_cb_major_types {
 130         MEI_READ = 0,
 131         MEI_WRITE,
 132         MEI_IOCTL,
 133         MEI_OPEN,
 134         MEI_CLOSE
 135 };
 136
 137 /*
 138  * Intel MEI message data struct
 139  */
 140 struct mei_message_data {
 141         u32 size;
 142         unsigned char *data;
 143 };
 144
 145
 146 struct mei_cl_cb {
 147         struct list_head cb_list;
 148         enum mei_cb_major_types major_file_operations;
 149         void *file_private;
 150         struct mei_message_data request_buffer;
 151         struct mei_message_data response_buffer;
 152         unsigned long information;
 153         unsigned long read_time;
 154         struct file *file_object;
 155 };
 156
 157 /* MEI client instance carried as file->pirvate_data*/
 158 struct mei_cl {
 159         struct list_head link;
 160         struct mei_device *dev;
 161         enum file_state state;
 162         wait_queue_head_t tx_wait;
 163         wait_queue_head_t rx_wait;
 164         wait_queue_head_t wait;
 165         int read_pending;
 166         int status;
 167         /* ID of client connected */
 168         u8 host_client_id;
 169         u8 me_client_id;
 170         u8 mei_flow_ctrl_creds;
 171         u8 timer_count;
 172         enum mei_file_transaction_states reading_state;
 173         enum mei_file_transaction_states writing_state;
 174         int sm_state;
 175         struct mei_cl_cb *read_cb;
 176 };
 177
 178 struct mei_io_list {
 179         struct mei_cl_cb mei_cb;
 180 };
 181
 182 /**
 183  * struct mei_deive -  MEI private device struct
 184  * @hbuf_depth - depth of host(write) buffer
 185  */
 186 struct mei_device {
 187         struct pci_dev *pdev;   /* pointer to pci device struct */
 188         /*
 189          * lists of queues
 190          */
 191          /* array of pointers to aio lists */
 192         struct mei_io_list read_list;           /* driver read queue */
 193         struct mei_io_list write_list;          /* driver write queue */
 194         struct mei_io_list write_waiting_list;  /* write waiting queue */
 195         struct mei_io_list ctrl_wr_list;        /* managed write IOCTL list */
 196         struct mei_io_list ctrl_rd_list;        /* managed read IOCTL list */
 197         struct mei_io_list amthi_cmd_list;      /* amthi list for cmd waiting */
 198
 199         /* driver managed amthi list for reading completed amthi cmd data */
 200         struct mei_io_list amthi_read_complete_list;
 201         /*
 202          * list of files
 203          */
 204         struct list_head file_list;
 205         long open_handle_count;
 206         /*
 207          * memory of device
 208          */
 209         unsigned int mem_base;
 210         unsigned int mem_length;
 211         void __iomem *mem_addr;
 212         /*
 213          * lock for the device
 214          */
 215         struct mutex device_lock; /* device lock */
 216         struct delayed_work timer_work; /* MEI timer delayed work (timeouts) */
 217         bool recvd_msg;
 218         /*
 219          * hw states of host and fw(ME)
 220          */
 221         u32 host_hw_state;
 222         u32 me_hw_state;
 223         u8  hbuf_depth;
 224         /*
 225          * waiting queue for receive message from FW
 226          */
 227         wait_queue_head_t wait_recvd_msg;
 228         wait_queue_head_t wait_stop_wd;
 229
 230         /*
 231          * mei device  states
 232          */
 233         enum mei_dev_state dev_state;
 234         enum mei_init_clients_states init_clients_state;
 235         u16 init_clients_timer;
 236         bool need_reset;
 237
 238         u32 extra_write_index;
 239         unsigned char rd_msg_buf[MEI_RD_MSG_BUF_SIZE];  /* control messages */
 240         u32 wr_msg_buf[128];    /* used for control messages */
 241         u32 ext_msg_buf[8];     /* for control responses */
 242         u32 rd_msg_hdr;
 243
 244         struct hbm_version version;
 245
 246         struct mei_me_client *me_clients; /* Note: memory has to be allocated */
 247         DECLARE_BITMAP(me_clients_map, MEI_CLIENTS_MAX);
 248         DECLARE_BITMAP(host_clients_map, MEI_CLIENTS_MAX);
 249         u8 me_clients_num;
 250         u8 me_client_presentation_num;
 251         u8 me_client_index;
 252         bool mei_host_buffer_is_empty;
 253
 254         struct mei_cl wd_cl;
 255         enum mei_wd_states wd_state;
 256         bool wd_interface_reg;
 257         bool wd_pending;
 258         u16 wd_timeout;
 259         unsigned char wd_data[MEI_WD_START_MSG_SIZE];
 260
 261
 262         struct file *iamthif_file_object;
 263         struct mei_cl iamthif_cl;
 264         struct mei_cl_cb *iamthif_current_cb;
 265         int iamthif_mtu;
 266         unsigned long iamthif_timer;
 267         u32 iamthif_stall_timer;
 268         unsigned char *iamthif_msg_buf; /* Note: memory has to be allocated */
 269         u32 iamthif_msg_buf_size;
 270         u32 iamthif_msg_buf_index;
 271         enum iamthif_states iamthif_state;
 272         bool iamthif_flow_control_pending;
 273         bool iamthif_ioctl;
 274         bool iamthif_canceled;
 275 };
 276
 277
 278 /*
 279  * mei init function prototypes
 280  */
 281 struct mei_device *mei_device_init(struct pci_dev *pdev);
 282 void mei_reset(struct mei_device *dev, int interrupts);
 283 int mei_hw_init(struct mei_device *dev);
 284 int mei_task_initialize_clients(void *data);
 285 int mei_initialize_clients(struct mei_device *dev);
 286 int mei_disconnect_host_client(struct mei_device *dev, struct mei_cl *cl);
 287 void mei_remove_client_from_file_list(struct mei_device *dev, u8 host_client_id);
 288 void mei_host_init_iamthif(struct mei_device *dev);
 289 void mei_allocate_me_clients_storage(struct mei_device *dev);
 290
 291
 292 int mei_me_cl_update_filext(struct mei_device *dev, struct mei_cl *cl,
 293                         const uuid_le *cguid, u8 host_client_id);
 294 int mei_me_cl_by_uuid(const struct mei_device *dev, const uuid_le *cuuid);
 295 int mei_me_cl_by_id(struct mei_device *dev, u8 client_id);
 296
 297 /*
 298  * MEI IO List Functions
 299  */
 300 void mei_io_list_init(struct mei_io_list *list);
 301 void mei_io_list_flush(struct mei_io_list *list, struct mei_cl *cl);
 302
 303 /*
 304  * MEI ME Client Functions
 305  */
 306
 307 struct mei_cl *mei_cl_allocate(struct mei_device *dev);
 308 void mei_cl_init(struct mei_cl *cl, struct mei_device *dev);
 309 int mei_cl_flush_queues(struct mei_cl *cl);
 310 /**
 311  * mei_cl_cmp_id - tells if file private data have same id
 312  *
 313  * @fe1: private data of 1. file object
 314  * @fe2: private data of 2. file object
 315  *
 316  * returns true  - if ids are the same and not NULL
 317  */
 318 static inline bool mei_cl_cmp_id(const struct mei_cl *cl1,
 319                                 const struct mei_cl *cl2)
 320 {
 321         return cl1 && cl2 &&
 322                 (cl1->host_client_id == cl2->host_client_id) &&
 323                 (cl1->me_client_id == cl2->me_client_id);
 324 }
 325
 326
 327
 328 /*
 329  * MEI Host Client Functions
 330  */
 331 void mei_host_start_message(struct mei_device *dev);
 332 void mei_host_enum_clients_message(struct mei_device *dev);
 333 int mei_host_client_properties(struct mei_device *dev);
 334
 335 /*
 336  *  MEI interrupt functions prototype
 337  */
 338 irqreturn_t mei_interrupt_quick_handler(int irq, void *dev_id);
 339 irqreturn_t mei_interrupt_thread_handler(int irq, void *dev_id);
 340 void mei_timer(struct work_struct *work);
 341
 342 /*
 343  *  MEI input output function prototype
 344  */
 345 int mei_ioctl_connect_client(struct file *file,
 346                         struct mei_connect_client_data *data);
 347
 348 int mei_start_read(struct mei_device *dev, struct mei_cl *cl);
 349
 350 int amthi_write(struct mei_device *dev, struct mei_cl_cb *priv_cb);
 351
 352 int amthi_read(struct mei_device *dev, struct file *file,
 353               char __user *ubuf, size_t length, loff_t *offset);
 354
 355 struct mei_cl_cb *find_amthi_read_list_entry(struct mei_device *dev,
 356                                                 struct file *file);
 357
 358 void mei_run_next_iamthif_cmd(struct mei_device *dev);
 359
 360 void mei_free_cb_private(struct mei_cl_cb *priv_cb);
 361
 362
 363 /*
 364  * Register Access Function
 365  */
 366
 367 /**
 368  * mei_reg_read - Reads 32bit data from the mei device
 369  *
 370  * @dev: the device structure
 371  * @offset: offset from which to read the data
 372  *
 373  * returns register value (u32)
 374  */
 375 static inline u32 mei_reg_read(const struct mei_device *dev,
 376                                unsigned long offset)
 377 {
 378         return ioread32(dev->mem_addr + offset);
 379 }
 380
 381 /**
 382  * mei_reg_write - Writes 32bit data to the mei device
 383  *
 384  * @dev: the device structure
 385  * @offset: offset from which to write the data
 386  * @value: register value to write (u32)
 387  */
 388 static inline void mei_reg_write(const struct mei_device *dev,
 389                                  unsigned long offset, u32 value)
 390 {
 391         iowrite32(value, dev->mem_addr + offset);
 392 }
 393
 394 /**
 395  * mei_hcsr_read - Reads 32bit data from the host CSR
 396  *
 397  * @dev: the device structure
 398  *
 399  * returns the byte read.
 400  */
 401 static inline u32 mei_hcsr_read(const struct mei_device *dev)
 402 {
 403         return mei_reg_read(dev, H_CSR);
 404 }
 405
 406 /**
 407  * mei_mecsr_read - Reads 32bit data from the ME CSR
 408  *
 409  * @dev: the device structure
 410  *
 411  * returns ME_CSR_HA register value (u32)
 412  */
 413 static inline u32 mei_mecsr_read(const struct mei_device *dev)
 414 {
 415         return mei_reg_read(dev, ME_CSR_HA);
 416 }
 417
 418 /**
 419  * get_me_cb_rw - Reads 32bit data from the mei ME_CB_RW register
 420  *
 421  * @dev: the device structure
 422  *
 423  * returns ME_CB_RW register value (u32)
 424  */
 425 static inline u32 mei_mecbrw_read(const struct mei_device *dev)
 426 {
 427         return mei_reg_read(dev, ME_CB_RW);
 428 }
 429
 430
 431 /*
 432  * mei interface function prototypes
 433  */
 434 void mei_hcsr_set(struct mei_device *dev);
 435 void mei_csr_clear_his(struct mei_device *dev);
 436
 437 void mei_enable_interrupts(struct mei_device *dev);
 438 void mei_disable_interrupts(struct mei_device *dev);
 439
 440 #endif