drtracing.org Git - deliverable/linux.git/blob

1 /*

2 *

3 * Intel Management Engine Interface (Intel MEI) Linux driver

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 */

17 #ifndef _MEI_DEV_H_

18 #define _MEI_DEV_H_

20 #include <linux/types.h>

21 #include <linux/watchdog.h>

22 #include <linux/poll.h>

23 #include <linux/mei.h>

24 #include <linux/mei_cl_bus.h>

26 #include "hw.h"

27 #include "hw-me-regs.h"

29 /*

30 * watch dog definition

31 */

32 #define MEI_WD_HDR_SIZE 4

33 #define MEI_WD_STOP_MSG_SIZE MEI_WD_HDR_SIZE

34 #define MEI_WD_START_MSG_SIZE (MEI_WD_HDR_SIZE + 16)

36 #define MEI_WD_DEFAULT_TIMEOUT 120 /* seconds */

37 #define MEI_WD_MIN_TIMEOUT 120 /* seconds */

38 #define MEI_WD_MAX_TIMEOUT 65535 /* seconds */

40 #define MEI_WD_STOP_TIMEOUT 10 /* msecs */

42 #define MEI_WD_STATE_INDEPENDENCE_MSG_SENT (1 << 0)

44 #define MEI_RD_MSG_BUF_SIZE (128 * sizeof(u32))

47 /*

48 * AMTHI Client UUID

49 */

50 extern const uuid_le mei_amthif_guid;

52 /*

53 * Watchdog Client UUID

54 */

55 extern const uuid_le mei_wd_guid;

57 /*

58 * Watchdog independence state message

59 */

60 extern const u8 mei_wd_state_independence_msg[3][4];

62 /*

63 * Number of Maximum MEI Clients

64 */

65 #define MEI_CLIENTS_MAX 256

67 /*

68 * Number of File descriptors/handles

69 * that can be opened to the driver.

70 *

71 * Limit to 255: 256 Total Clients

72 * minus internal client for MEI Bus Messags

73 */

74 #define MEI_MAX_OPEN_HANDLE_COUNT (MEI_CLIENTS_MAX - 1)

76 /*

77 * Internal Clients Number

78 */

79 #define MEI_HOST_CLIENT_ID_ANY (-1)

80 #define MEI_HBM_HOST_CLIENT_ID 0 /* not used, just for documentation */

81 #define MEI_WD_HOST_CLIENT_ID 1

82 #define MEI_IAMTHIF_HOST_CLIENT_ID 2

85 /* File state */

86 enum file_state {

87 MEI_FILE_INITIALIZING = 0,

88 MEI_FILE_CONNECTING,

89 MEI_FILE_CONNECTED,

90 MEI_FILE_DISCONNECTING,

91 MEI_FILE_DISCONNECTED

92 };

94 /* MEI device states */

95 enum mei_dev_state {

96 MEI_DEV_INITIALIZING = 0,

97 MEI_DEV_INIT_CLIENTS,

98 MEI_DEV_ENABLED,

99 MEI_DEV_RESETING,

100 MEI_DEV_DISABLED,

101 MEI_DEV_POWER_DOWN,

102 MEI_DEV_POWER_UP

103 };

104

105 const char *mei_dev_state_str(int state);

106

107 /* init clients states*/

108 enum mei_init_clients_states {

109 MEI_START_MESSAGE = 0,

110 MEI_ENUM_CLIENTS_MESSAGE,

111 MEI_CLIENT_PROPERTIES_MESSAGE

112 };

113

114 enum iamthif_states {

115 MEI_IAMTHIF_IDLE,

116 MEI_IAMTHIF_WRITING,

117 MEI_IAMTHIF_FLOW_CONTROL,

118 MEI_IAMTHIF_READING,

119 MEI_IAMTHIF_READ_COMPLETE

120 };

121

122 enum mei_file_transaction_states {

123 MEI_IDLE,

124 MEI_WRITING,

125 MEI_WRITE_COMPLETE,

126 MEI_FLOW_CONTROL,

127 MEI_READING,

128 MEI_READ_COMPLETE

129 };

130

131 enum mei_wd_states {

132 MEI_WD_IDLE,

133 MEI_WD_RUNNING,

134 MEI_WD_STOPPING,

135 };

136

137 /**

138 * enum mei_cb_file_ops - file operation associated with the callback

139 * @MEI_FOP_READ - read

140 * @MEI_FOP_WRITE - write

141 * @MEI_FOP_IOCTL - ioctl

142 * @MEI_FOP_OPEN - open

143 * @MEI_FOP_CLOSE - close

144 */

145 enum mei_cb_file_ops {

146 MEI_FOP_READ = 0,

147 MEI_FOP_WRITE,

148 MEI_FOP_IOCTL,

149 MEI_FOP_OPEN,

150 MEI_FOP_CLOSE

151 };

152

153 /*

154 * Intel MEI message data struct

155 */

156 struct mei_msg_data {

157 u32 size;

158 unsigned char *data;

159 };

160

161 /**

162 * struct mei_me_client - representation of me (fw) client

163 *

164 * @props - client properties

165 * @client_id - me client id

166 * @mei_flow_ctrl_creds - flow control credits

167 */

168 struct mei_me_client {

169 struct mei_client_properties props;

170 u8 client_id;

171 u8 mei_flow_ctrl_creds;

172 };

173

174

175 struct mei_cl;

176

177 /**

178 * struct mei_cl_cb - file operation callback structure

179 *

180 * @cl - file client who is running this operation

181 * @fop_type - file operation type

182 */

183 struct mei_cl_cb {

184 struct list_head list;

185 struct mei_cl *cl;

186 enum mei_cb_file_ops fop_type;

187 struct mei_msg_data request_buffer;

188 struct mei_msg_data response_buffer;

189 unsigned long buf_idx;

190 unsigned long read_time;

191 struct file *file_object;

192 };

193

194 /* MEI client instance carried as file->pirvate_data*/

195 struct mei_cl {

196 struct list_head link;

197 struct mei_device *dev;

198 enum file_state state;

199 wait_queue_head_t tx_wait;

200 wait_queue_head_t rx_wait;

201 wait_queue_head_t wait;

202 int status;

203 /* ID of client connected */

204 u8 host_client_id;

205 u8 me_client_id;

206 u8 mei_flow_ctrl_creds;

207 u8 timer_count;

208 enum mei_file_transaction_states reading_state;

209 enum mei_file_transaction_states writing_state;

210 int sm_state;

211 struct mei_cl_cb *read_cb;

212

213 /* MEI CL bus data */

214 struct mei_cl_device *device;

215 struct list_head device_link;

216 uuid_le device_uuid;

217 };

218

219 /** struct mei_hw_ops

220 *

221 * @host_is_ready - query for host readiness

222

223 * @hw_is_ready - query if hw is ready

224 * @hw_reset - reset hw

225 * @hw_start - start hw after reset

226 * @hw_config - configure hw

227

228 * @intr_clear - clear pending interrupts

229 * @intr_enable - enable interrupts

230 * @intr_disable - disable interrupts

231

232 * @hbuf_free_slots - query for write buffer empty slots

233 * @hbuf_is_ready - query if write buffer is empty

234 * @hbuf_max_len - query for write buffer max len

235

236 * @write - write a message to FW

237

238 * @rdbuf_full_slots - query how many slots are filled

239

240 * @read_hdr - get first 4 bytes (header)

241 * @read - read a buffer from the FW

242 */

243 struct mei_hw_ops {

244

245 bool (*host_is_ready) (struct mei_device *dev);

246

247 bool (*hw_is_ready) (struct mei_device *dev);

248 void (*hw_reset) (struct mei_device *dev, bool enable);

249 int (*hw_start) (struct mei_device *dev);

250 void (*hw_config) (struct mei_device *dev);

251

252 void (*intr_clear) (struct mei_device *dev);

253 void (*intr_enable) (struct mei_device *dev);

254 void (*intr_disable) (struct mei_device *dev);

255

256 int (*hbuf_free_slots) (struct mei_device *dev);

257 bool (*hbuf_is_ready) (struct mei_device *dev);

258 size_t (*hbuf_max_len) (const struct mei_device *dev);

259

260 int (*write)(struct mei_device *dev,

261 struct mei_msg_hdr *hdr,

262 unsigned char *buf);

263

264 int (*rdbuf_full_slots)(struct mei_device *dev);

265

266 u32 (*read_hdr)(const struct mei_device *dev);

267 int (*read) (struct mei_device *dev,

268 unsigned char *buf, unsigned long len);

269 };

270

271 /* MEI bus API*/

272

273 /**

274 * struct mei_cl_ops - MEI CL device ops

275 * This structure allows ME host clients to implement technology

276 * specific operations.

277 *

278 * @enable: Enable an MEI CL device. Some devices require specific

279 * HECI commands to initialize completely.

280 * @disable: Disable an MEI CL device.

281 * @send: Tx hook for the device. This allows ME host clients to trap

282 * the device driver buffers before actually physically

283 * pushing it to the ME.

284 * @recv: Rx hook for the device. This allows ME host clients to trap the

285 * ME buffers before forwarding them to the device driver.

286 */

287 struct mei_cl_ops {

288 int (*enable)(struct mei_cl_device *device);

289 int (*disable)(struct mei_cl_device *device);

290 int (*send)(struct mei_cl_device *device, u8 *buf, size_t length);

291 int (*recv)(struct mei_cl_device *device, u8 *buf, size_t length);

292 };

293

294 struct mei_cl_device *mei_cl_add_device(struct mei_device *dev,

295 uuid_le uuid, char *name,

296 struct mei_cl_ops *ops);

297 void mei_cl_remove_device(struct mei_cl_device *device);

298

299 int __mei_cl_async_send(struct mei_cl *cl, u8 *buf, size_t length);

300 int __mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length);

301 int __mei_cl_recv(struct mei_cl *cl, u8 *buf, size_t length);

302 void mei_cl_bus_rx_event(struct mei_cl *cl);

303 int mei_cl_bus_init(void);

304 void mei_cl_bus_exit(void);

305

306

307 /**

308 * struct mei_cl_device - MEI device handle

309 * An mei_cl_device pointer is returned from mei_add_device()

310 * and links MEI bus clients to their actual ME host client pointer.

311 * Drivers for MEI devices will get an mei_cl_device pointer

312 * when being probed and shall use it for doing ME bus I/O.

313 *

314 * @dev: linux driver model device pointer

315 * @uuid: me client uuid

316 * @cl: mei client

317 * @ops: ME transport ops

318 * @event_cb: Drivers register this callback to get asynchronous ME

319 * events (e.g. Rx buffer pending) notifications.

320 * @events: Events bitmask sent to the driver.

321 * @priv_data: client private data

322 */

323 struct mei_cl_device {

324 struct device dev;

325

326 struct mei_cl *cl;

327

328 const struct mei_cl_ops *ops;

329

330 struct work_struct event_work;

331 mei_cl_event_cb_t event_cb;

332 void *event_context;

333 unsigned long events;

334

335 void *priv_data;

336 };

337

338 /**

339 * struct mei_device - MEI private device struct

340

341 * @mem_addr - mem mapped base register address

342

343 * @hbuf_depth - depth of hardware host/write buffer is slots

344 * @hbuf_is_ready - query if the host host/write buffer is ready

345 * @wr_msg - the buffer for hbm control messages

346 * @wr_ext_msg - the buffer for hbm control responses (set in read cycle)

347 */

348 struct mei_device {

349 struct pci_dev *pdev; /* pointer to pci device struct */

350 /*

351 * lists of queues

352 */

353 /* array of pointers to aio lists */

354 struct mei_cl_cb read_list; /* driver read queue */

355 struct mei_cl_cb write_list; /* driver write queue */

356 struct mei_cl_cb write_waiting_list; /* write waiting queue */

357 struct mei_cl_cb ctrl_wr_list; /* managed write IOCTL list */

358 struct mei_cl_cb ctrl_rd_list; /* managed read IOCTL list */

359

360 /*

361 * list of files

362 */

363 struct list_head file_list;

364 long open_handle_count;

365

366 /*

367 * lock for the device

368 */

369 struct mutex device_lock; /* device lock */

370 struct delayed_work timer_work; /* MEI timer delayed work (timeouts) */

371

372 bool recvd_hw_ready;

373 bool recvd_msg;

374

375 /*

376 * waiting queue for receive message from FW

377 */

378 wait_queue_head_t wait_hw_ready;

379 wait_queue_head_t wait_recvd_msg;

380 wait_queue_head_t wait_stop_wd;

381

382 /*

383 * mei device states

384 */

385 enum mei_dev_state dev_state;

386 enum mei_init_clients_states init_clients_state;

387 u16 init_clients_timer;

388

389 unsigned char rd_msg_buf[MEI_RD_MSG_BUF_SIZE]; /* control messages */

390 u32 rd_msg_hdr;

391

392 /* write buffer */

393 u8 hbuf_depth;

394 bool hbuf_is_ready;

395

396 /* used for control messages */

397 struct {

398 struct mei_msg_hdr hdr;

399 unsigned char data[128];

400 } wr_msg;

401

402 struct {

403 struct mei_msg_hdr hdr;

404 unsigned char data[4]; /* All HBM messages are 4 bytes */

405 } wr_ext_msg; /* for control responses */

406

407 struct hbm_version version;

408

409 struct mei_me_client *me_clients; /* Note: memory has to be allocated */

410 DECLARE_BITMAP(me_clients_map, MEI_CLIENTS_MAX);

411 DECLARE_BITMAP(host_clients_map, MEI_CLIENTS_MAX);

412 u8 me_clients_num;

413 u8 me_client_presentation_num;

414 u8 me_client_index;

415

416 struct mei_cl wd_cl;

417 enum mei_wd_states wd_state;

418 bool wd_pending;

419 u16 wd_timeout;

420 unsigned char wd_data[MEI_WD_START_MSG_SIZE];

421

422

423 /* amthif list for cmd waiting */

424 struct mei_cl_cb amthif_cmd_list;

425 /* driver managed amthif list for reading completed amthif cmd data */

426 struct mei_cl_cb amthif_rd_complete_list;

427 struct file *iamthif_file_object;

428 struct mei_cl iamthif_cl;

429 struct mei_cl_cb *iamthif_current_cb;

430 int iamthif_mtu;

431 unsigned long iamthif_timer;

432 u32 iamthif_stall_timer;

433 unsigned char *iamthif_msg_buf; /* Note: memory has to be allocated */

434 u32 iamthif_msg_buf_size;

435 u32 iamthif_msg_buf_index;

436 enum iamthif_states iamthif_state;

437 bool iamthif_flow_control_pending;

438 bool iamthif_ioctl;

439 bool iamthif_canceled;

440

441 struct work_struct init_work;

442

443 /* List of bus devices */

444 struct list_head device_list;

445

446 #if IS_ENABLED(CONFIG_DEBUG_FS)

447 struct dentry *dbgfs_dir;

448 #endif /* CONFIG_DEBUG_FS */

449

450

451 const struct mei_hw_ops *ops;

452 char hw[0] __aligned(sizeof(void *));

453 };

454

455 static inline unsigned long mei_secs_to_jiffies(unsigned long sec)

456 {

457 return msecs_to_jiffies(sec * MSEC_PER_SEC);

458 }

459

460 /**

461 * mei_data2slots - get slots - number of (dwords) from a message length

462 * + size of the mei header

463 * @length - size of the messages in bytes

464 * returns - number of slots

465 */

466 static inline u32 mei_data2slots(size_t length)

467 {

468 return DIV_ROUND_UP(sizeof(struct mei_msg_hdr) + length, 4);

469 }

470

471 /*

472 * mei init function prototypes

473 */

474 void mei_device_init(struct mei_device *dev);

475 void mei_reset(struct mei_device *dev, int interrupts);

476 int mei_start(struct mei_device *dev);

477 void mei_stop(struct mei_device *dev);

478

479 /*

480 * MEI interrupt functions prototype

481 */

482

483 void mei_timer(struct work_struct *work);

484 int mei_irq_read_handler(struct mei_device *dev,

485 struct mei_cl_cb *cmpl_list, s32 *slots);

486

487 int mei_irq_write_handler(struct mei_device *dev, struct mei_cl_cb *cmpl_list);

488 void mei_irq_compl_handler(struct mei_device *dev, struct mei_cl_cb *cmpl_list);

489

490 /*

491 * AMTHIF - AMT Host Interface Functions

492 */

493 void mei_amthif_reset_params(struct mei_device *dev);

494

495 int mei_amthif_host_init(struct mei_device *dev);

496

497 int mei_amthif_write(struct mei_device *dev, struct mei_cl_cb *priv_cb);

498

499 int mei_amthif_read(struct mei_device *dev, struct file *file,

500 char __user *ubuf, size_t length, loff_t *offset);

501

502 unsigned int mei_amthif_poll(struct mei_device *dev,

503 struct file *file, poll_table *wait);

504

505 int mei_amthif_release(struct mei_device *dev, struct file *file);

506

507 struct mei_cl_cb *mei_amthif_find_read_list_entry(struct mei_device *dev,

508 struct file *file);

509

510 void mei_amthif_run_next_cmd(struct mei_device *dev);

511

512

513 int mei_amthif_irq_write_complete(struct mei_device *dev, s32 *slots,

514 struct mei_cl_cb *cb, struct mei_cl_cb *cmpl_list);

515

516 void mei_amthif_complete(struct mei_device *dev, struct mei_cl_cb *cb);

517 int mei_amthif_irq_read_message(struct mei_cl_cb *complete_list,

518 struct mei_device *dev, struct mei_msg_hdr *mei_hdr);

519 int mei_amthif_irq_read(struct mei_device *dev, s32 *slots);

520

521

522 int mei_wd_send(struct mei_device *dev);

523 int mei_wd_stop(struct mei_device *dev);

524 int mei_wd_host_init(struct mei_device *dev);

525 /*

526 * mei_watchdog_register - Registering watchdog interface

527 * once we got connection to the WD Client

528 * @dev - mei device

529 */

530 void mei_watchdog_register(struct mei_device *dev);

531 /*

532 * mei_watchdog_unregister - Unregistering watchdog interface

533 * @dev - mei device

534 */

535 void mei_watchdog_unregister(struct mei_device *dev);

536

537 /*

538 * Register Access Function

539 */

540

541 static inline void mei_hw_config(struct mei_device *dev)

542 {

543 dev->ops->hw_config(dev);

544 }

545 static inline void mei_hw_reset(struct mei_device *dev, bool enable)

546 {

547 dev->ops->hw_reset(dev, enable);

548 }

549

550 static inline void mei_hw_start(struct mei_device *dev)

551 {

552 dev->ops->hw_start(dev);

553 }

554

555 static inline void mei_clear_interrupts(struct mei_device *dev)

556 {

557 dev->ops->intr_clear(dev);

558 }

559

560 static inline void mei_enable_interrupts(struct mei_device *dev)

561 {

562 dev->ops->intr_enable(dev);

563 }

564

565 static inline void mei_disable_interrupts(struct mei_device *dev)

566 {

567 dev->ops->intr_disable(dev);

568 }

569

570 static inline bool mei_host_is_ready(struct mei_device *dev)

571 {

572 return dev->ops->host_is_ready(dev);

573 }

574 static inline bool mei_hw_is_ready(struct mei_device *dev)

575 {

576 return dev->ops->hw_is_ready(dev);

577 }

578

579 static inline bool mei_hbuf_is_ready(struct mei_device *dev)

580 {

581 return dev->ops->hbuf_is_ready(dev);

582 }

583

584 static inline int mei_hbuf_empty_slots(struct mei_device *dev)

585 {

586 return dev->ops->hbuf_free_slots(dev);

587 }

588

589 static inline size_t mei_hbuf_max_len(const struct mei_device *dev)

590 {

591 return dev->ops->hbuf_max_len(dev);

592 }

593

594 static inline int mei_write_message(struct mei_device *dev,

595 struct mei_msg_hdr *hdr,

596 unsigned char *buf)

597 {

598 return dev->ops->write(dev, hdr, buf);

599 }

600

601 static inline u32 mei_read_hdr(const struct mei_device *dev)

602 {

603 return dev->ops->read_hdr(dev);

604 }

605

606 static inline void mei_read_slots(struct mei_device *dev,

607 unsigned char *buf, unsigned long len)

608 {

609 dev->ops->read(dev, buf, len);

610 }

611

612 static inline int mei_count_full_read_slots(struct mei_device *dev)

613 {

614 return dev->ops->rdbuf_full_slots(dev);

615 }

616

617 #if IS_ENABLED(CONFIG_DEBUG_FS)

618 int mei_dbgfs_register(struct mei_device *dev, const char *name);

619 void mei_dbgfs_deregister(struct mei_device *dev);

620 #else

621 static inline int mei_dbgfs_register(struct mei_device *dev, const char *name)

622 {

623 return 0;

624 }

625 static inline void mei_dbgfs_deregister(struct mei_device *dev) {}

626 #endif /* CONFIG_DEBUG_FS */

627

628 int mei_register(struct mei_device *dev);

629 void mei_deregister(struct mei_device *dev);

630

631 #define MEI_HDR_FMT "hdr:host=%02d me=%02d len=%d comp=%1d"

632 #define MEI_HDR_PRM(hdr) \

633 (hdr)->host_addr, (hdr)->me_addr, \

634 (hdr)->length, (hdr)->msg_complete

635

636 #endif