?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ASoC: Remove duplicate ADC/DAC widgets from wm_hubs.c
[linux/fpc-iii.git] / drivers / staging / heci / interrupt.c
blob2a3a01a62bbf748d3fe43e6cb0718d8242c6add8
1 /*
2 * Part of Intel(R) Manageability Engine Interface Linux driver
3 *
4 * Copyright (c) 2003 - 2008 Intel Corp.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions, and the following disclaimer,
12 * without modification.
13 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
14 * substantially similar to the "NO WARRANTY" disclaimer below
15 * ("Disclaimer") and any redistribution must be conditioned upon
16 * including a substantially similar Disclaimer requirement for further
17 * binary redistribution.
18 * 3. Neither the names of the above-listed copyright holders nor the names
19 * of any contributors may be used to endorse or promote products derived
20 * from this software without specific prior written permission.
21 *
22 * Alternatively, this software may be distributed under the terms of the
23 * GNU General Public License ("GPL") version 2 as published by the Free
24 * Software Foundation.
25 *
26 * NO WARRANTY
27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
30 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
31 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
35 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
36 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 * POSSIBILITY OF SUCH DAMAGES.
38 *
39 */
40
41 #include <linux/kthread.h>
42
43 #include "heci.h"
44 #include "heci_interface.h"
45
46 /*
47 * interrupt function prototypes
48 */
49 static void heci_bh_handler(struct work_struct *work);
50 static int heci_bh_read_handler(struct io_heci_list *complete_list,
51 struct iamt_heci_device *dev,
52 __s32 *slots);
53 static int heci_bh_write_handler(struct io_heci_list *complete_list,
54 struct iamt_heci_device *dev,
55 __s32 *slots);
56 static void heci_bh_read_bus_message(struct iamt_heci_device *dev,
57 struct heci_msg_hdr *heci_hdr);
58 static int heci_bh_read_pthi_message(struct io_heci_list *complete_list,
59 struct iamt_heci_device *dev,
60 struct heci_msg_hdr *heci_hdr);
61 static int heci_bh_read_client_message(struct io_heci_list *complete_list,
62 struct iamt_heci_device *dev,
63 struct heci_msg_hdr *heci_hdr);
64 static void heci_client_connect_response(struct iamt_heci_device *dev,
65 struct hbm_client_connect_response *connect_res);
66 static void heci_client_disconnect_response(struct iamt_heci_device *dev,
67 struct hbm_client_connect_response *disconnect_res);
68 static void heci_client_flow_control_response(struct iamt_heci_device *dev,
69 struct hbm_flow_control *flow_control);
70 static void heci_client_disconnect_request(struct iamt_heci_device *dev,
71 struct hbm_client_disconnect_request *disconnect_req);
72
73
74 /**
75 * heci_isr_interrupt - The ISR of the HECI device
76 *
77 * @irq: The irq number
78 * @dev_id: pointer to the device structure
79 *
80 * returns irqreturn_t
81 */
82 irqreturn_t heci_isr_interrupt(int irq, void *dev_id)
83 {
84 int err;
85 struct iamt_heci_device *dev = (struct iamt_heci_device *) dev_id;
86
87 dev->host_hw_state = read_heci_register(dev, H_CSR);
88
89 if ((dev->host_hw_state & H_IS) != H_IS)
90 return IRQ_NONE;
91
92 /* disable interrupts */
93 heci_csr_disable_interrupts(dev);
94
95 /* clear H_IS bit in H_CSR */
96 heci_csr_clear_his(dev);
97
98 /*
99 * Our device interrupted, schedule work the heci_bh_handler
100 * to handle the interrupt processing. This needs to be a
101 * workqueue item since the handler can sleep.
102 */
103 PREPARE_WORK(&dev->work, heci_bh_handler);
104 DBG("schedule work the heci_bh_handler.\n");
105 err = schedule_work(&dev->work);
106 if (!err)
107 DBG("heci_bh_handler was already on the workqueue.\n");
108 return IRQ_HANDLED;
109 }
110
111 /**
112 * _heci_cmpl - process completed operation.
113 *
114 * @file_ext: private data of the file object.
115 * @priv_cb_pos: callback block.
116 */
117 static void _heci_cmpl(struct heci_file_private *file_ext,
118 struct heci_cb_private *priv_cb_pos)
119 {
120 if (priv_cb_pos->major_file_operations == HECI_WRITE) {
121 heci_free_cb_private(priv_cb_pos);
122 DBG("completing write call back.\n");
123 file_ext->writing_state = HECI_WRITE_COMPLETE;
124 if ((&file_ext->tx_wait) &&
125 waitqueue_active(&file_ext->tx_wait))
126 wake_up_interruptible(&file_ext->tx_wait);
127
128 } else if (priv_cb_pos->major_file_operations == HECI_READ
129 && HECI_READING == file_ext->reading_state) {
130 DBG("completing read call back information= %lu\n",
131 priv_cb_pos->information);
132 file_ext->reading_state = HECI_READ_COMPLETE;
133 if ((&file_ext->rx_wait) &&
134 waitqueue_active(&file_ext->rx_wait))
135 wake_up_interruptible(&file_ext->rx_wait);
136
137 }
138 }
139
140 /**
141 * _heci_cmpl_iamthif - process completed iamthif operation.
142 *
143 * @dev: Device object for our driver.
144 * @priv_cb_pos: callback block.
145 */
146 static void _heci_cmpl_iamthif(struct iamt_heci_device *dev,
147 struct heci_cb_private *priv_cb_pos)
148 {
149 if (dev->iamthif_canceled != 1) {
150 dev->iamthif_state = HECI_IAMTHIF_READ_COMPLETE;
151 dev->iamthif_stall_timer = 0;
152 memcpy(priv_cb_pos->response_buffer.data,
153 dev->iamthif_msg_buf,
154 dev->iamthif_msg_buf_index);
155 list_add_tail(&priv_cb_pos->cb_list,
156 &dev->pthi_read_complete_list.heci_cb.cb_list);
157 DBG("pthi read completed.\n");
158 } else {
159 run_next_iamthif_cmd(dev);
160 }
161 if (&dev->iamthif_file_ext.wait) {
162 DBG("completing pthi call back.\n");
163 wake_up_interruptible(&dev->iamthif_file_ext.wait);
164 }
165 }
166 /**
167 * heci_bh_handler - function called after ISR to handle the interrupt
168 * processing.
169 *
170 * @work: pointer to the work structure
171 *
172 * NOTE: This function is called by schedule work
173 */
174 static void heci_bh_handler(struct work_struct *work)
175 {
176 struct iamt_heci_device *dev =
177 container_of(work, struct iamt_heci_device, work);
178 struct io_heci_list complete_list;
179 __s32 slots;
180 int rets;
181 struct heci_cb_private *cb_pos = NULL, *cb_next = NULL;
182 struct heci_file_private *file_ext;
183 int bus_message_received = 0;
184 struct task_struct *tsk;
185
186 DBG("function called after ISR to handle the interrupt processing.\n");
187 /* initialize our complete list */
188 spin_lock_bh(&dev->device_lock);
189 heci_initialize_list(&complete_list, dev);
190 dev->host_hw_state = read_heci_register(dev, H_CSR);
191 dev->me_hw_state = read_heci_register(dev, ME_CSR_HA);
192
193 /* check if ME wants a reset */
194 if (((dev->me_hw_state & ME_RDY_HRA) == 0)
195 && (dev->heci_state != HECI_RESETING)
196 && (dev->heci_state != HECI_INITIALIZING)) {
197 DBG("FW not ready.\n");
198 heci_reset(dev, 1);
199 spin_unlock_bh(&dev->device_lock);
200 return;
201 }
202
203 /* check if we need to start the dev */
204 if ((dev->host_hw_state & H_RDY) == 0) {
205 if ((dev->me_hw_state & ME_RDY_HRA) == ME_RDY_HRA) {
206 DBG("we need to start the dev.\n");
207 dev->host_hw_state |= (H_IE | H_IG | H_RDY);
208 heci_set_csr_register(dev);
209 if (dev->heci_state == HECI_INITIALIZING) {
210 dev->recvd_msg = 1;
211 spin_unlock_bh(&dev->device_lock);
212 wake_up_interruptible(&dev->wait_recvd_msg);
213 return;
214
215 } else {
216 spin_unlock_bh(&dev->device_lock);
217 tsk = kthread_run(heci_task_initialize_clients,
218 dev, "heci_reinit");
219 if (IS_ERR(tsk)) {
220 int rc = PTR_ERR(tsk);
221 printk(KERN_WARNING "heci: Unable to"
222 "start the heci thread: %d\n", rc);
223 }
224 return;
225 }
226 } else {
227 DBG("enable interrupt FW not ready.\n");
228 heci_csr_enable_interrupts(dev);
229 spin_unlock_bh(&dev->device_lock);
230 return;
231 }
232 }
233 /* check slots avalable for reading */
234 slots = count_full_read_slots(dev);
235 DBG("slots =%08x extra_write_index =%08x.\n",
236 slots, dev->extra_write_index);
237 while ((slots > 0) && (!dev->extra_write_index)) {
238 DBG("slots =%08x extra_write_index =%08x.\n", slots,
239 dev->extra_write_index);
240 DBG("call heci_bh_read_handler.\n");
241 rets = heci_bh_read_handler(&complete_list, dev, &slots);
242 if (rets != 0)
243 goto end;
244 }
245 rets = heci_bh_write_handler(&complete_list, dev, &slots);
246 end:
247 DBG("end of bottom half function.\n");
248 dev->host_hw_state = read_heci_register(dev, H_CSR);
249 dev->host_buffer_is_empty = host_buffer_is_empty(dev);
250
251 if ((dev->host_hw_state & H_IS) == H_IS) {
252 /* acknowledge interrupt and disable interrupts */
253 heci_csr_disable_interrupts(dev);
254
255 /* clear H_IS bit in H_CSR */
256 heci_csr_clear_his(dev);
257
258 PREPARE_WORK(&dev->work, heci_bh_handler);
259 DBG("schedule work the heci_bh_handler.\n");
260 rets = schedule_work(&dev->work);
261 if (!rets)
262 DBG("heci_bh_handler was already queued.\n");
263 } else {
264 heci_csr_enable_interrupts(dev);
265 }
266
267 if (dev->recvd_msg && waitqueue_active(&dev->wait_recvd_msg)) {
268 DBG("received waiting bus message\n");
269 bus_message_received = 1;
270 }
271 spin_unlock_bh(&dev->device_lock);
272 if (bus_message_received) {
273 DBG("wake up dev->wait_recvd_msg\n");
274 wake_up_interruptible(&dev->wait_recvd_msg);
275 bus_message_received = 0;
276 }
277 if ((complete_list.status != 0)
278 || list_empty(&complete_list.heci_cb.cb_list))
279 return;
280
281
282 list_for_each_entry_safe(cb_pos, cb_next,
283 &complete_list.heci_cb.cb_list, cb_list) {
284 file_ext = (struct heci_file_private *)cb_pos->file_private;
285 list_del(&cb_pos->cb_list);
286 if (file_ext != NULL) {
287 if (file_ext != &dev->iamthif_file_ext) {
288 DBG("completing call back.\n");
289 _heci_cmpl(file_ext, cb_pos);
290 cb_pos = NULL;
291 } else if (file_ext == &dev->iamthif_file_ext) {
292 _heci_cmpl_iamthif(dev, cb_pos);
293 }
294 }
295 }
296 }
297
298
299 /**
300 * heci_bh_read_handler - bottom half read routine after ISR to
301 * handle the read processing.
302 *
303 * @cmpl_list: An instance of our list structure
304 * @dev: Device object for our driver
305 * @slots: slots to read.
306 *
307 * returns 0 on success, <0 on failure.
308 */
309 static int heci_bh_read_handler(struct io_heci_list *cmpl_list,
310 struct iamt_heci_device *dev,
311 __s32 *slots)
312 {
313 struct heci_msg_hdr *heci_hdr;
314 int ret = 0;
315 struct heci_file_private *file_pos = NULL;
316 struct heci_file_private *file_next = NULL;
317
318 if (!dev->rd_msg_hdr) {
319 dev->rd_msg_hdr = read_heci_register(dev, ME_CB_RW);
320 DBG("slots=%08x.\n", *slots);
321 (*slots)--;
322 DBG("slots=%08x.\n", *slots);
323 }
324 heci_hdr = (struct heci_msg_hdr *) &dev->rd_msg_hdr;
325 DBG("heci_hdr->length =%d\n", heci_hdr->length);
326
327 if ((heci_hdr->reserved) || !(dev->rd_msg_hdr)) {
328 DBG("corrupted message header.\n");
329 ret = -ECORRUPTED_MESSAGE_HEADER;
330 goto end;
331 }
332
333 if ((heci_hdr->host_addr) || (heci_hdr->me_addr)) {
334 list_for_each_entry_safe(file_pos, file_next,
335 &dev->file_list, link) {
336 DBG("list_for_each_entry_safe read host"
337 " client = %d, ME client = %d\n",
338 file_pos->host_client_id,
339 file_pos->me_client_id);
340 if ((file_pos->host_client_id == heci_hdr->host_addr)
341 && (file_pos->me_client_id == heci_hdr->me_addr))
342 break;
343 }
344
345 if (&file_pos->link == &dev->file_list) {
346 DBG("corrupted message header\n");
347 ret = -ECORRUPTED_MESSAGE_HEADER;
348 goto end;
349 }
350 }
351 if (((*slots) * sizeof(__u32)) < heci_hdr->length) {
352 DBG("we can't read the message slots=%08x.\n", *slots);
353 /* we can't read the message */
354 ret = -ERANGE;
355 goto end;
356 }
357
358 /* decide where to read the message too */
359 if (!heci_hdr->host_addr) {
360 DBG("call heci_bh_read_bus_message.\n");
361 heci_bh_read_bus_message(dev, heci_hdr);
362 DBG("end heci_bh_read_bus_message.\n");
363 } else if ((heci_hdr->host_addr == dev->iamthif_file_ext.host_client_id)
364 && (HECI_FILE_CONNECTED == dev->iamthif_file_ext.state)
365 && (dev->iamthif_state == HECI_IAMTHIF_READING)) {
366 DBG("call heci_bh_read_iamthif_message.\n");
367 DBG("heci_hdr->length =%d\n", heci_hdr->length);
368 ret = heci_bh_read_pthi_message(cmpl_list, dev, heci_hdr);
369 if (ret != 0)
370 goto end;
371
372 } else {
373 DBG("call heci_bh_read_client_message.\n");
374 ret = heci_bh_read_client_message(cmpl_list, dev, heci_hdr);
375 if (ret != 0)
376 goto end;
377
378 }
379
380 /* reset the number of slots and header */
381 *slots = count_full_read_slots(dev);
382 dev->rd_msg_hdr = 0;
383
384 if (*slots == -ESLOTS_OVERFLOW) {
385 /* overflow - reset */
386 DBG("reseting due to slots overflow.\n");
387 /* set the event since message has been read */
388 ret = -ERANGE;
389 goto end;
390 }
391 end:
392 return ret;
393 }
394
395
396 /**
397 * heci_bh_read_bus_message - bottom half read routine after ISR to
398 * handle the read bus message cmd processing.
399 *
400 * @dev: Device object for our driver
401 * @heci_hdr: header of bus message
402 */
403 static void heci_bh_read_bus_message(struct iamt_heci_device *dev,
404 struct heci_msg_hdr *heci_hdr)
405 {
406 struct heci_bus_message *heci_msg;
407 struct hbm_host_version_response *version_res;
408 struct hbm_client_connect_response *connect_res;
409 struct hbm_client_connect_response *disconnect_res;
410 struct hbm_flow_control *flow_control;
411 struct hbm_props_response *props_res;
412 struct hbm_host_enum_response *enum_res;
413 struct hbm_client_disconnect_request *disconnect_req;
414 struct hbm_host_stop_request *h_stop_req;
415 int i;
416 unsigned char *buffer;
417
418 /* read the message to our buffer */
419 buffer = (unsigned char *) dev->rd_msg_buf;
420 BUG_ON(heci_hdr->length >= sizeof(dev->rd_msg_buf));
421 heci_read_slots(dev, buffer, heci_hdr->length);
422 heci_msg = (struct heci_bus_message *) buffer;
423
424 switch (*(__u8 *) heci_msg) {
425 case HOST_START_RES_CMD:
426 version_res = (struct hbm_host_version_response *) heci_msg;
427 if (version_res->host_version_supported) {
428 dev->version.major_version = HBM_MAJOR_VERSION;
429 dev->version.minor_version = HBM_MINOR_VERSION;
430 } else {
431 dev->version = version_res->me_max_version;
432 }
433 dev->recvd_msg = 1;
434 DBG("host start response message received.\n");
435 break;
436
437 case CLIENT_CONNECT_RES_CMD:
438 connect_res =
439 (struct hbm_client_connect_response *) heci_msg;
440 heci_client_connect_response(dev, connect_res);
441 DBG("client connect response message received.\n");
442 wake_up(&dev->wait_recvd_msg);
443 break;
444
445 case CLIENT_DISCONNECT_RES_CMD:
446 disconnect_res =
447 (struct hbm_client_connect_response *) heci_msg;
448 heci_client_disconnect_response(dev, disconnect_res);
449 DBG("client disconnect response message received.\n");
450 wake_up(&dev->wait_recvd_msg);
451 break;
452
453 case HECI_FLOW_CONTROL_CMD:
454 flow_control = (struct hbm_flow_control *) heci_msg;
455 heci_client_flow_control_response(dev, flow_control);
456 DBG("client flow control response message received.\n");
457 break;
458
459 case HOST_CLIENT_PROPERTEIS_RES_CMD:
460 props_res = (struct hbm_props_response *) heci_msg;
461 if (props_res->status != 0) {
462 BUG();
463 break;
464 }
465 for (i = 0; i < dev->num_heci_me_clients; i++) {
466 if (dev->me_clients[i].client_id ==
467 props_res->address) {
468 dev->me_clients[i].props =
469 props_res->client_properties;
470 break;
471 }
472
473 }
474 dev->recvd_msg = 1;
475 break;
476
477 case HOST_ENUM_RES_CMD:
478 enum_res = (struct hbm_host_enum_response *) heci_msg;
479 memcpy(dev->heci_me_clients, enum_res->valid_addresses, 32);
480 dev->recvd_msg = 1;
481 break;
482
483 case HOST_STOP_RES_CMD:
484 dev->heci_state = HECI_DISABLED;
485 DBG("reseting because of FW stop response.\n");
486 heci_reset(dev, 1);
487 break;
488
489 case CLIENT_DISCONNECT_REQ_CMD:
490 /* search for client */
491 disconnect_req =
492 (struct hbm_client_disconnect_request *) heci_msg;
493 heci_client_disconnect_request(dev, disconnect_req);
494 break;
495
496 case ME_STOP_REQ_CMD:
497 /* prepare stop request */
498 heci_hdr = (struct heci_msg_hdr *) &dev->ext_msg_buf[0];
499 heci_hdr->host_addr = 0;
500 heci_hdr->me_addr = 0;
501 heci_hdr->length = sizeof(struct hbm_host_stop_request);
502 heci_hdr->msg_complete = 1;
503 heci_hdr->reserved = 0;
504 h_stop_req =
505 (struct hbm_host_stop_request *) &dev->ext_msg_buf[1];
506 memset(h_stop_req, 0, sizeof(struct hbm_host_stop_request));
507 h_stop_req->cmd.cmd = HOST_STOP_REQ_CMD;
508 h_stop_req->reason = DRIVER_STOP_REQUEST;
509 h_stop_req->reserved[0] = 0;
510 h_stop_req->reserved[1] = 0;
511 dev->extra_write_index = 2;
512 break;
513
514 default:
515 BUG();
516 break;
517
518 }
519 }
520
521 /**
522 * heci_bh_read_pthi_message - bottom half read routine after ISR to
523 * handle the read pthi message data processing.
524 *
525 * @complete_list: An instance of our list structure
526 * @dev: Device object for our driver
527 * @heci_hdr: header of pthi message
528 *
529 * returns 0 on success, <0 on failure.
530 */
531 static int heci_bh_read_pthi_message(struct io_heci_list *complete_list,
532 struct iamt_heci_device *dev,
533 struct heci_msg_hdr *heci_hdr)
534 {
535 struct heci_file_private *file_ext;
536 struct heci_cb_private *priv_cb;
537 unsigned char *buffer;
538
539 BUG_ON(heci_hdr->me_addr != dev->iamthif_file_ext.me_client_id);
540 BUG_ON(dev->iamthif_state != HECI_IAMTHIF_READING);
541
542 buffer = (unsigned char *) (dev->iamthif_msg_buf +
543 dev->iamthif_msg_buf_index);
544 BUG_ON(sizeof(dev->iamthif_msg_buf) <
545 (dev->iamthif_msg_buf_index + heci_hdr->length));
546
547 heci_read_slots(dev, buffer, heci_hdr->length);
548
549 dev->iamthif_msg_buf_index += heci_hdr->length;
550
551 if (!(heci_hdr->msg_complete))
552 return 0;
553
554 DBG("pthi_message_buffer_index=%d\n", heci_hdr->length);
555 DBG("completed pthi read.\n ");
556 if (!dev->iamthif_current_cb)
557 return -ENODEV;
558
559 priv_cb = dev->iamthif_current_cb;
560 dev->iamthif_current_cb = NULL;
561
562 file_ext = (struct heci_file_private *)priv_cb->file_private;
563 if (!file_ext)
564 return -ENODEV;
565
566 dev->iamthif_stall_timer = 0;
567 priv_cb->information = dev->iamthif_msg_buf_index;
568 priv_cb->read_time = get_seconds();
569 if ((dev->iamthif_ioctl) && (file_ext == &dev->iamthif_file_ext)) {
570 /* found the iamthif cb */
571 DBG("complete the pthi read cb.\n ");
572 if (&dev->iamthif_file_ext) {
573 DBG("add the pthi read cb to complete.\n ");
574 list_add_tail(&priv_cb->cb_list,
575 &complete_list->heci_cb.cb_list);
576 }
577 }
578 return 0;
579 }
580
581 /**
582 * _heci_bh_state_ok - check if heci header matches file private data
583 *
584 * @file_ext: private data of the file object
585 * @heci_hdr: header of heci client message
586 *
587 * returns !=0 if matches, 0 if no match.
588 */
589 static int _heci_bh_state_ok(struct heci_file_private *file_ext,
590 struct heci_msg_hdr *heci_hdr)
591 {
592 return ((file_ext->host_client_id == heci_hdr->host_addr)
593 && (file_ext->me_client_id == heci_hdr->me_addr)
594 && (file_ext->state == HECI_FILE_CONNECTED)
595 && (HECI_READ_COMPLETE != file_ext->reading_state));
596 }
597
598 /**
599 * heci_bh_read_client_message - bottom half read routine after ISR to
600 * handle the read heci client message data processing.
601 *
602 * @complete_list: An instance of our list structure
603 * @dev: Device object for our driver
604 * @heci_hdr: header of heci client message
605 *
606 * returns 0 on success, <0 on failure.
607 */
608 static int heci_bh_read_client_message(struct io_heci_list *complete_list,
609 struct iamt_heci_device *dev,
610 struct heci_msg_hdr *heci_hdr)
611 {
612 struct heci_file_private *file_ext;
613 struct heci_cb_private *priv_cb_pos = NULL, *priv_cb_next = NULL;
614 unsigned char *buffer = NULL;
615
616 DBG("start client msg\n");
617 if (!((dev->read_list.status == 0) &&
618 !list_empty(&dev->read_list.heci_cb.cb_list)))
619 goto quit;
620
621 list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
622 &dev->read_list.heci_cb.cb_list, cb_list) {
623 file_ext = (struct heci_file_private *)
624 priv_cb_pos->file_private;
625 if ((file_ext != NULL) &&
626 (_heci_bh_state_ok(file_ext, heci_hdr))) {
627 spin_lock_bh(&file_ext->read_io_lock);
628 file_ext->reading_state = HECI_READING;
629 buffer = (unsigned char *)
630 (priv_cb_pos->response_buffer.data +
631 priv_cb_pos->information);
632 BUG_ON(priv_cb_pos->response_buffer.size <
633 heci_hdr->length +
634 priv_cb_pos->information);
635
636 if (priv_cb_pos->response_buffer.size <
637 heci_hdr->length +
638 priv_cb_pos->information) {
639 DBG("message overflow.\n");
640 list_del(&priv_cb_pos->cb_list);
641 spin_unlock_bh(&file_ext->read_io_lock);
642 return -ENOMEM;
643 }
644 if (buffer) {
645 heci_read_slots(dev, buffer,
646 heci_hdr->length);
647 }
648 priv_cb_pos->information += heci_hdr->length;
649 if (heci_hdr->msg_complete) {
650 file_ext->status = 0;
651 list_del(&priv_cb_pos->cb_list);
652 spin_unlock_bh(&file_ext->read_io_lock);
653 DBG("completed read host client = %d,"
654 "ME client = %d, "
655 "data length = %lu\n",
656 file_ext->host_client_id,
657 file_ext->me_client_id,
658 priv_cb_pos->information);
659
660 *(priv_cb_pos->response_buffer.data +
661 priv_cb_pos->information) = '\0';
662 DBG("priv_cb_pos->res_buffer - %s\n",
663 priv_cb_pos->response_buffer.data);
664 list_add_tail(&priv_cb_pos->cb_list,
665 &complete_list->heci_cb.cb_list);
666 } else {
667 spin_unlock_bh(&file_ext->read_io_lock);
668 }
669
670 break;
671 }
672
673 }
674
675 quit:
676 DBG("message read\n");
677 if (!buffer) {
678 heci_read_slots(dev, (unsigned char *) dev->rd_msg_buf,
679 heci_hdr->length);
680 DBG("discarding message, header=%08x.\n",
681 *(__u32 *) dev->rd_msg_buf);
682 }
683
684 return 0;
685 }
686
687 /**
688 * _heci_bh_iamthif_read - prepare to read iamthif data.
689 *
690 * @dev: Device object for our driver.
691 * @slots: free slots.
692 *
693 * returns 0, OK; otherwise, error.
694 */
695 static int _heci_bh_iamthif_read(struct iamt_heci_device *dev, __s32 *slots)
696 {
697
698 if (((*slots) * sizeof(__u32)) >= (sizeof(struct heci_msg_hdr)
699 + sizeof(struct hbm_flow_control))) {
700 *slots -= (sizeof(struct heci_msg_hdr) +
701 sizeof(struct hbm_flow_control) + 3) / 4;
702 if (!heci_send_flow_control(dev, &dev->iamthif_file_ext)) {
703 DBG("iamthif flow control failed\n");
704 } else {
705 DBG("iamthif flow control success\n");
706 dev->iamthif_state = HECI_IAMTHIF_READING;
707 dev->iamthif_flow_control_pending = 0;
708 dev->iamthif_msg_buf_index = 0;
709 dev->iamthif_msg_buf_size = 0;
710 dev->iamthif_stall_timer = IAMTHIF_STALL_TIMER;
711 dev->host_buffer_is_empty = host_buffer_is_empty(dev);
712 }
713 return 0;
714 } else {
715 return -ECOMPLETE_MESSAGE;
716 }
717 }
718
719 /**
720 * _heci_bh_close - process close related operation.
721 *
722 * @dev: Device object for our driver.
723 * @slots: free slots.
724 * @priv_cb_pos: callback block.
725 * @file_ext: private data of the file object.
726 * @cmpl_list: complete list.
727 *
728 * returns 0, OK; otherwise, error.
729 */
730 static int _heci_bh_close(struct iamt_heci_device *dev, __s32 *slots,
731 struct heci_cb_private *priv_cb_pos,
732 struct heci_file_private *file_ext,
733 struct io_heci_list *cmpl_list)
734 {
735 if ((*slots * sizeof(__u32)) >= (sizeof(struct heci_msg_hdr) +
736 sizeof(struct hbm_client_disconnect_request))) {
737 *slots -= (sizeof(struct heci_msg_hdr) +
738 sizeof(struct hbm_client_disconnect_request) + 3) / 4;
739
740 if (!heci_disconnect(dev, file_ext)) {
741 file_ext->status = 0;
742 priv_cb_pos->information = 0;
743 list_move_tail(&priv_cb_pos->cb_list,
744 &cmpl_list->heci_cb.cb_list);
745 return -ECOMPLETE_MESSAGE;
746 } else {
747 file_ext->state = HECI_FILE_DISCONNECTING;
748 file_ext->status = 0;
749 priv_cb_pos->information = 0;
750 list_move_tail(&priv_cb_pos->cb_list,
751 &dev->ctrl_rd_list.heci_cb.cb_list);
752 file_ext->timer_count = HECI_CONNECT_TIMEOUT;
753 }
754 } else {
755 /* return the cancel routine */
756 return -ECORRUPTED_MESSAGE_HEADER;
757 }
758
759 return 0;
760 }
761
762 /**
763 * _heci_hb_close - process read related operation.
764 *
765 * @dev: Device object for our driver.
766 * @slots: free slots.
767 * @priv_cb_pos: callback block.
768 * @file_ext: private data of the file object.
769 * @cmpl_list: complete list.
770 *
771 * returns 0, OK; otherwise, error.
772 */
773 static int _heci_bh_read(struct iamt_heci_device *dev, __s32 *slots,
774 struct heci_cb_private *priv_cb_pos,
775 struct heci_file_private *file_ext,
776 struct io_heci_list *cmpl_list)
777 {
778 if ((*slots * sizeof(__u32)) >= (sizeof(struct heci_msg_hdr) +
779 sizeof(struct hbm_flow_control))) {
780 *slots -= (sizeof(struct heci_msg_hdr) +
781 sizeof(struct hbm_flow_control) + 3) / 4;
782 if (!heci_send_flow_control(dev, file_ext)) {
783 file_ext->status = -ENODEV;
784 priv_cb_pos->information = 0;
785 list_move_tail(&priv_cb_pos->cb_list,
786 &cmpl_list->heci_cb.cb_list);
787 return -ENODEV;
788 } else {
789 list_move_tail(&priv_cb_pos->cb_list,
790 &dev->read_list.heci_cb.cb_list);
791 }
792 } else {
793 /* return the cancel routine */
794 list_del(&priv_cb_pos->cb_list);
795 return -ECORRUPTED_MESSAGE_HEADER;
796 }
797
798 return 0;
799 }
800
801
802 /**
803 * _heci_bh_ioctl - process ioctl related operation.
804 *
805 * @dev: Device object for our driver.
806 * @slots: free slots.
807 * @priv_cb_pos: callback block.
808 * @file_ext: private data of the file object.
809 * @cmpl_list: complete list.
810 *
811 * returns 0, OK; otherwise, error.
812 */
813 static int _heci_bh_ioctl(struct iamt_heci_device *dev, __s32 *slots,
814 struct heci_cb_private *priv_cb_pos,
815 struct heci_file_private *file_ext,
816 struct io_heci_list *cmpl_list)
817 {
818 if ((*slots * sizeof(__u32)) >= (sizeof(struct heci_msg_hdr) +
819 sizeof(struct hbm_client_connect_request))) {
820 file_ext->state = HECI_FILE_CONNECTING;
821 *slots -= (sizeof(struct heci_msg_hdr) +
822 sizeof(struct hbm_client_connect_request) + 3) / 4;
823 if (!heci_connect(dev, file_ext)) {
824 file_ext->status = -ENODEV;
825 priv_cb_pos->information = 0;
826 list_del(&priv_cb_pos->cb_list);
827 return -ENODEV;
828 } else {
829 list_move_tail(&priv_cb_pos->cb_list,
830 &dev->ctrl_rd_list.heci_cb.cb_list);
831 file_ext->timer_count = HECI_CONNECT_TIMEOUT;
832 }
833 } else {
834 /* return the cancel routine */
835 list_del(&priv_cb_pos->cb_list);
836 return -ECORRUPTED_MESSAGE_HEADER;
837 }
838
839 return 0;
840 }
841
842 /**
843 * _heci_bh_cmpl - process completed and no-iamthif operation.
844 *
845 * @dev: Device object for our driver.
846 * @slots: free slots.
847 * @priv_cb_pos: callback block.
848 * @file_ext: private data of the file object.
849 * @cmpl_list: complete list.
850 *
851 * returns 0, OK; otherwise, error.
852 */
853 static int _heci_bh_cmpl(struct iamt_heci_device *dev, __s32 *slots,
854 struct heci_cb_private *priv_cb_pos,
855 struct heci_file_private *file_ext,
856 struct io_heci_list *cmpl_list)
857 {
858 struct heci_msg_hdr *heci_hdr;
859
860 if ((*slots * sizeof(__u32)) >= (sizeof(struct heci_msg_hdr) +
861 (priv_cb_pos->request_buffer.size -
862 priv_cb_pos->information))) {
863 heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
864 heci_hdr->host_addr = file_ext->host_client_id;
865 heci_hdr->me_addr = file_ext->me_client_id;
866 heci_hdr->length = ((priv_cb_pos->request_buffer.size) -
867 (priv_cb_pos->information));
868 heci_hdr->msg_complete = 1;
869 heci_hdr->reserved = 0;
870 DBG("priv_cb_pos->request_buffer.size =%d"
871 "heci_hdr->msg_complete= %d\n",
872 priv_cb_pos->request_buffer.size,
873 heci_hdr->msg_complete);
874 DBG("priv_cb_pos->information =%lu\n",
875 priv_cb_pos->information);
876 DBG("heci_hdr->length =%d\n",
877 heci_hdr->length);
878 *slots -= (sizeof(struct heci_msg_hdr) +
879 heci_hdr->length + 3) / 4;
880 if (!heci_write_message(dev, heci_hdr,
881 (unsigned char *)
882 (priv_cb_pos->request_buffer.data +
883 priv_cb_pos->information),
884 heci_hdr->length)) {
885 file_ext->status = -ENODEV;
886 list_move_tail(&priv_cb_pos->cb_list,
887 &cmpl_list->heci_cb.cb_list);
888 return -ENODEV;
889 } else {
890 flow_ctrl_reduce(dev, file_ext);
891 file_ext->status = 0;
892 priv_cb_pos->information += heci_hdr->length;
893 list_move_tail(&priv_cb_pos->cb_list,
894 &dev->write_waiting_list.heci_cb.cb_list);
895 }
896 } else if (*slots == ((dev->host_hw_state & H_CBD) >> 24)) {
897 /* buffer is still empty */
898 heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
899 heci_hdr->host_addr = file_ext->host_client_id;
900 heci_hdr->me_addr = file_ext->me_client_id;
901 heci_hdr->length =
902 (*slots * sizeof(__u32)) - sizeof(struct heci_msg_hdr);
903 heci_hdr->msg_complete = 0;
904 heci_hdr->reserved = 0;
905
906 (*slots) -= (sizeof(struct heci_msg_hdr) +
907 heci_hdr->length + 3) / 4;
908 if (!heci_write_message(dev, heci_hdr,
909 (unsigned char *)
910 (priv_cb_pos->request_buffer.data +
911 priv_cb_pos->information),
912 heci_hdr->length)) {
913 file_ext->status = -ENODEV;
914 list_move_tail(&priv_cb_pos->cb_list,
915 &cmpl_list->heci_cb.cb_list);
916 return -ENODEV;
917 } else {
918 priv_cb_pos->information += heci_hdr->length;
919 DBG("priv_cb_pos->request_buffer.size =%d"
920 " heci_hdr->msg_complete= %d\n",
921 priv_cb_pos->request_buffer.size,
922 heci_hdr->msg_complete);
923 DBG("priv_cb_pos->information =%lu\n",
924 priv_cb_pos->information);
925 DBG("heci_hdr->length =%d\n", heci_hdr->length);
926 }
927 return -ECOMPLETE_MESSAGE;
928 } else {
929 return -ECORRUPTED_MESSAGE_HEADER;
930 }
931
932 return 0;
933 }
934
935 /**
936 * _heci_bh_cmpl_iamthif - process completed iamthif operation.
937 *
938 * @dev: Device object for our driver.
939 * @slots: free slots.
940 * @priv_cb_pos: callback block.
941 * @file_ext: private data of the file object.
942 * @cmpl_list: complete list.
943 *
944 * returns 0, OK; otherwise, error.
945 */
946 static int _heci_bh_cmpl_iamthif(struct iamt_heci_device *dev, __s32 *slots,
947 struct heci_cb_private *priv_cb_pos,
948 struct heci_file_private *file_ext,
949 struct io_heci_list *cmpl_list)
950 {
951 struct heci_msg_hdr *heci_hdr;
952
953 if ((*slots * sizeof(__u32)) >= (sizeof(struct heci_msg_hdr) +
954 dev->iamthif_msg_buf_size -
955 dev->iamthif_msg_buf_index)) {
956 heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
957 heci_hdr->host_addr = file_ext->host_client_id;
958 heci_hdr->me_addr = file_ext->me_client_id;
959 heci_hdr->length = dev->iamthif_msg_buf_size -
960 dev->iamthif_msg_buf_index;
961 heci_hdr->msg_complete = 1;
962 heci_hdr->reserved = 0;
963
964 *slots -= (sizeof(struct heci_msg_hdr) +
965 heci_hdr->length + 3) / 4;
966
967 if (!heci_write_message(dev, heci_hdr,
968 (dev->iamthif_msg_buf +
969 dev->iamthif_msg_buf_index),
970 heci_hdr->length)) {
971 dev->iamthif_state = HECI_IAMTHIF_IDLE;
972 file_ext->status = -ENODEV;
973 list_del(&priv_cb_pos->cb_list);
974 return -ENODEV;
975 } else {
976 flow_ctrl_reduce(dev, file_ext);
977 dev->iamthif_msg_buf_index += heci_hdr->length;
978 priv_cb_pos->information = dev->iamthif_msg_buf_index;
979 file_ext->status = 0;
980 dev->iamthif_state = HECI_IAMTHIF_FLOW_CONTROL;
981 dev->iamthif_flow_control_pending = 1;
982 /* save iamthif cb sent to pthi client */
983 dev->iamthif_current_cb = priv_cb_pos;
984 list_move_tail(&priv_cb_pos->cb_list,
985 &dev->write_waiting_list.heci_cb.cb_list);
986
987 }
988 } else if (*slots == ((dev->host_hw_state & H_CBD) >> 24)) {
989 /* buffer is still empty */
990 heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
991 heci_hdr->host_addr = file_ext->host_client_id;
992 heci_hdr->me_addr = file_ext->me_client_id;
993 heci_hdr->length =
994 (*slots * sizeof(__u32)) - sizeof(struct heci_msg_hdr);
995 heci_hdr->msg_complete = 0;
996 heci_hdr->reserved = 0;
997
998 *slots -= (sizeof(struct heci_msg_hdr) +
999 heci_hdr->length + 3) / 4;
1000
1001 if (!heci_write_message(dev, heci_hdr,
1002 (dev->iamthif_msg_buf +
1003 dev->iamthif_msg_buf_index),
1004 heci_hdr->length)) {
1005 file_ext->status = -ENODEV;
1006 list_del(&priv_cb_pos->cb_list);
1007 } else {
1008 dev->iamthif_msg_buf_index += heci_hdr->length;
1009 }
1010 return -ECOMPLETE_MESSAGE;
1011 } else {
1012 return -ECORRUPTED_MESSAGE_HEADER;
1013 }
1014
1015 return 0;
1016 }
1017
1018 /**
1019 * heci_bh_write_handler - bottom half write routine after
1020 * ISR to handle the write processing.
1021 *
1022 * @cmpl_list: An instance of our list structure
1023 * @dev: Device object for our driver
1024 * @slots: slots to write.
1025 *
1026 * returns 0 on success, <0 on failure.
1027 */
1028 static int heci_bh_write_handler(struct io_heci_list *cmpl_list,
1029 struct iamt_heci_device *dev,
1030 __s32 *slots)
1031 {
1032
1033 struct heci_file_private *file_ext;
1034 struct heci_cb_private *priv_cb_pos = NULL, *priv_cb_next = NULL;
1035 struct io_heci_list *list;
1036 int ret;
1037
1038 if (!host_buffer_is_empty(dev)) {
1039 DBG("host buffer is not empty.\n");
1040 return 0;
1041 }
1042 dev->write_hang = -1;
1043 *slots = count_empty_write_slots(dev);
1044 /* complete all waiting for write CB */
1045 DBG("complete all waiting for write cb.\n");
1046
1047 list = &dev->write_waiting_list;
1048 if ((list->status == 0)
1049 && !list_empty(&list->heci_cb.cb_list)) {
1050 list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
1051 &list->heci_cb.cb_list, cb_list) {
1052 file_ext = (struct heci_file_private *)
1053 priv_cb_pos->file_private;
1054 if (file_ext != NULL) {
1055 file_ext->status = 0;
1056 list_del(&priv_cb_pos->cb_list);
1057 if ((HECI_WRITING == file_ext->writing_state) &&
1058 (priv_cb_pos->major_file_operations ==
1059 HECI_WRITE) &&
1060 (file_ext != &dev->iamthif_file_ext)) {
1061 DBG("HECI WRITE COMPLETE\n");
1062 file_ext->writing_state =
1063 HECI_WRITE_COMPLETE;
1064 list_add_tail(&priv_cb_pos->cb_list,
1065 &cmpl_list->heci_cb.cb_list);
1066 }
1067 if (file_ext == &dev->iamthif_file_ext) {
1068 DBG("check iamthif flow control.\n");
1069 if (dev->iamthif_flow_control_pending) {
1070 ret = _heci_bh_iamthif_read(dev,
1071 slots);
1072 if (ret != 0)
1073 return ret;
1074 }
1075 }
1076 }
1077
1078 }
1079 }
1080
1081 if ((dev->stop) && (!dev->wd_pending)) {
1082 dev->wd_stoped = 1;
1083 wake_up_interruptible(&dev->wait_stop_wd);
1084 return 0;
1085 }
1086
1087 if (dev->extra_write_index != 0) {
1088 DBG("extra_write_index =%d.\n", dev->extra_write_index);
1089 heci_write_message(dev,
1090 (struct heci_msg_hdr *) &dev->ext_msg_buf[0],
1091 (unsigned char *) &dev->ext_msg_buf[1],
1092 (dev->extra_write_index - 1) * sizeof(__u32));
1093 *slots -= dev->extra_write_index;
1094 dev->extra_write_index = 0;
1095 }
1096 if (dev->heci_state == HECI_ENABLED) {
1097 if ((dev->wd_pending)
1098 && flow_ctrl_creds(dev, &dev->wd_file_ext)) {
1099 if (!heci_send_wd(dev))
1100 DBG("wd send failed.\n");
1101 else
1102 flow_ctrl_reduce(dev, &dev->wd_file_ext);
1103
1104 dev->wd_pending = 0;
1105
1106 if (dev->wd_timeout != 0) {
1107 *slots -= (sizeof(struct heci_msg_hdr) +
1108 HECI_START_WD_DATA_SIZE + 3) / 4;
1109 dev->wd_due_counter = 2;
1110 } else {
1111 *slots -= (sizeof(struct heci_msg_hdr) +
1112 HECI_WD_PARAMS_SIZE + 3) / 4;
1113 dev->wd_due_counter = 0;
1114 }
1115
1116 }
1117 }
1118 if (dev->stop)
1119 return ~ENODEV;
1120
1121 /* complete control write list CB */
1122 if (dev->ctrl_wr_list.status == 0) {
1123 /* complete control write list CB */
1124 DBG("complete control write list cb.\n");
1125 list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
1126 &dev->ctrl_wr_list.heci_cb.cb_list, cb_list) {
1127 file_ext = (struct heci_file_private *)
1128 priv_cb_pos->file_private;
1129 if (file_ext == NULL) {
1130 list_del(&priv_cb_pos->cb_list);
1131 return -ENODEV;
1132 }
1133 switch (priv_cb_pos->major_file_operations) {
1134 case HECI_CLOSE:
1135 /* send disconnect message */
1136 ret = _heci_bh_close(dev, slots,
1137 priv_cb_pos,
1138 file_ext, cmpl_list);
1139 if (ret != 0)
1140 return ret;
1141
1142 break;
1143 case HECI_READ:
1144 /* send flow control message */
1145 ret = _heci_bh_read(dev, slots,
1146 priv_cb_pos,
1147 file_ext, cmpl_list);
1148 if (ret != 0)
1149 return ret;
1150
1151 break;
1152 case HECI_IOCTL:
1153 /* connect message */
1154 if (!other_client_is_connecting(dev, file_ext))
1155 continue;
1156 ret = _heci_bh_ioctl(dev, slots,
1157 priv_cb_pos,
1158 file_ext, cmpl_list);
1159 if (ret != 0)
1160 return ret;
1161
1162 break;
1163
1164 default:
1165 BUG();
1166 }
1167
1168 }
1169 }
1170 /* complete write list CB */
1171 if ((dev->write_list.status == 0)
1172 && !list_empty(&dev->write_list.heci_cb.cb_list)) {
1173 DBG("complete write list cb.\n");
1174 list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
1175 &dev->write_list.heci_cb.cb_list, cb_list) {
1176 file_ext = (struct heci_file_private *)
1177 priv_cb_pos->file_private;
1178
1179 if (file_ext != NULL) {
1180 if (file_ext != &dev->iamthif_file_ext) {
1181 if (!flow_ctrl_creds(dev, file_ext)) {
1182 DBG("No flow control"
1183 " credentials for client"
1184 " %d, not sending.\n",
1185 file_ext->host_client_id);
1186 continue;
1187 }
1188 ret = _heci_bh_cmpl(dev, slots,
1189 priv_cb_pos,
1190 file_ext,
1191 cmpl_list);
1192 if (ret != 0)
1193 return ret;
1194
1195 } else if (file_ext == &dev->iamthif_file_ext) {
1196 /* IAMTHIF IOCTL */
1197 DBG("complete pthi write cb.\n");
1198 if (!flow_ctrl_creds(dev, file_ext)) {
1199 DBG("No flow control"
1200 " credentials for pthi"
1201 " client %d.\n",
1202 file_ext->host_client_id);
1203 continue;
1204 }
1205 ret = _heci_bh_cmpl_iamthif(dev, slots,
1206 priv_cb_pos,
1207 file_ext,
1208 cmpl_list);
1209 if (ret != 0)
1210 return ret;
1211
1212 }
1213 }
1214
1215 }
1216 }
1217 return 0;
1218 }
1219
1220
1221 /**
1222 * is_treat_specially_client - check if the message belong
1223 * to the file private data.
1224 *
1225 * @file_ext: private data of the file object
1226 * @rs: connect response bus message
1227 * @dev: Device object for our driver
1228 *
1229 * returns 0 on success, <0 on failure.
1230 */
1231 static int is_treat_specially_client(struct heci_file_private *file_ext,
1232 struct hbm_client_connect_response *rs)
1233 {
1234 int ret = 0;
1235
1236 if ((file_ext->host_client_id == rs->host_addr) &&
1237 (file_ext->me_client_id == rs->me_addr)) {
1238 if (rs->status == 0) {
1239 DBG("client connect status = 0x%08x.\n", rs->status);
1240 file_ext->state = HECI_FILE_CONNECTED;
1241 file_ext->status = 0;
1242 } else {
1243 DBG("client connect status = 0x%08x.\n", rs->status);
1244 file_ext->state = HECI_FILE_DISCONNECTED;
1245 file_ext->status = -ENODEV;
1246 }
1247 ret = 1;
1248 }
1249 DBG("client state = %d.\n", file_ext->state);
1250 return ret;
1251 }
1252
1253 /**
1254 * heci_client_connect_response - connect response bh routine
1255 *
1256 * @dev: Device object for our driver
1257 * @rs: connect response bus message
1258 */
1259 static void heci_client_connect_response(struct iamt_heci_device *dev,
1260 struct hbm_client_connect_response *rs)
1261 {
1262
1263 struct heci_file_private *file_ext;
1264 struct heci_cb_private *priv_cb_pos = NULL, *priv_cb_next = NULL;
1265
1266 /* if WD or iamthif client treat specially */
1267
1268 if ((is_treat_specially_client(&(dev->wd_file_ext), rs)) ||
1269 (is_treat_specially_client(&(dev->iamthif_file_ext), rs)))
1270 return;
1271
1272 if (dev->ctrl_rd_list.status == 0
1273 && !list_empty(&dev->ctrl_rd_list.heci_cb.cb_list)) {
1274 list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
1275 &dev->ctrl_rd_list.heci_cb.cb_list, cb_list) {
1276 file_ext = (struct heci_file_private *)
1277 priv_cb_pos->file_private;
1278 if (file_ext == NULL) {
1279 list_del(&priv_cb_pos->cb_list);
1280 return;
1281 }
1282 if (HECI_IOCTL == priv_cb_pos->major_file_operations) {
1283 if (is_treat_specially_client(file_ext, rs)) {
1284 list_del(&priv_cb_pos->cb_list);
1285 file_ext->status = 0;
1286 file_ext->timer_count = 0;
1287 break;
1288 }
1289 }
1290 }
1291 }
1292 }
1293
1294 /**
1295 * heci_client_disconnect_response - disconnect response bh routine
1296 *
1297 * @dev: Device object for our driver
1298 * @rs: disconnect response bus message
1299 */
1300 static void heci_client_disconnect_response(struct iamt_heci_device *dev,
1301 struct hbm_client_connect_response *rs)
1302 {
1303 struct heci_file_private *file_ext;
1304 struct heci_cb_private *priv_cb_pos = NULL, *priv_cb_next = NULL;
1305
1306 if (dev->ctrl_rd_list.status == 0
1307 && !list_empty(&dev->ctrl_rd_list.heci_cb.cb_list)) {
1308 list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
1309 &dev->ctrl_rd_list.heci_cb.cb_list, cb_list) {
1310 file_ext = (struct heci_file_private *)
1311 priv_cb_pos->file_private;
1312
1313 if (file_ext == NULL) {
1314 list_del(&priv_cb_pos->cb_list);
1315 return;
1316 }
1317
1318 DBG("list_for_each_entry_safe in ctrl_rd_list.\n");
1319 if ((file_ext->host_client_id == rs->host_addr) &&
1320 (file_ext->me_client_id == rs->me_addr)) {
1321
1322 list_del(&priv_cb_pos->cb_list);
1323 if (rs->status == 0) {
1324 file_ext->state =
1325 HECI_FILE_DISCONNECTED;
1326 }
1327
1328 file_ext->status = 0;
1329 file_ext->timer_count = 0;
1330 break;
1331 }
1332 }
1333 }
1334 }
1335
1336 /**
1337 * same_flow_addr - tell they have same address.
1338 *
1339 * @file: private data of the file object.
1340 * @flow: flow control.
1341 *
1342 * returns !=0, same; 0,not.
1343 */
1344 static int same_flow_addr(struct heci_file_private *file,
1345 struct hbm_flow_control *flow)
1346 {
1347 return ((file->host_client_id == flow->host_addr)
1348 && (file->me_client_id == flow->me_addr));
1349 }
1350
1351 /**
1352 * add_single_flow_creds - add single buffer credentials.
1353 *
1354 * @file: private data ot the file object.
1355 * @flow: flow control.
1356 */
1357 static void add_single_flow_creds(struct iamt_heci_device *dev,
1358 struct hbm_flow_control *flow)
1359 {
1360 struct heci_me_client *client;
1361 int i;
1362
1363 for (i = 0; i < dev->num_heci_me_clients; i++) {
1364 client = &dev->me_clients[i];
1365 if ((client != NULL) &&
1366 (flow->me_addr == client->client_id)) {
1367 if (client->props.single_recv_buf != 0) {
1368 client->flow_ctrl_creds++;
1369 DBG("recv flow ctrl msg ME %d (single).\n",
1370 flow->me_addr);
1371 DBG("flow control credentials=%d.\n",
1372 client->flow_ctrl_creds);
1373 } else {
1374 BUG(); /* error in flow control */
1375 }
1376 }
1377 }
1378 }
1379
1380 /**
1381 * heci_client_flow_control_response - flow control response bh routine
1382 *
1383 * @dev: Device object for our driver
1384 * @flow_control: flow control response bus message
1385 */
1386 static void heci_client_flow_control_response(struct iamt_heci_device *dev,
1387 struct hbm_flow_control *flow_control)
1388 {
1389 struct heci_file_private *file_pos = NULL;
1390 struct heci_file_private *file_next = NULL;
1391
1392 if (flow_control->host_addr == 0) {
1393 /* single receive buffer */
1394 add_single_flow_creds(dev, flow_control);
1395 } else {
1396 /* normal connection */
1397 list_for_each_entry_safe(file_pos, file_next,
1398 &dev->file_list, link) {
1399 DBG("list_for_each_entry_safe in file_list\n");
1400
1401 DBG("file_ext of host client %d ME client %d.\n",
1402 file_pos->host_client_id,
1403 file_pos->me_client_id);
1404 DBG("flow ctrl msg for host %d ME %d.\n",
1405 flow_control->host_addr,
1406 flow_control->me_addr);
1407 if (same_flow_addr(file_pos, flow_control)) {
1408 DBG("recv ctrl msg for host %d ME %d.\n",
1409 flow_control->host_addr,
1410 flow_control->me_addr);
1411 file_pos->flow_ctrl_creds++;
1412 DBG("flow control credentials=%d.\n",
1413 file_pos->flow_ctrl_creds);
1414 break;
1415 }
1416 }
1417 }
1418 }
1419
1420 /**
1421 * same_disconn_addr - tell they have same address
1422 *
1423 * @file: private data of the file object.
1424 * @disconn: disconnection request.
1425 *
1426 * returns !=0, same; 0,not.
1427 */
1428 static int same_disconn_addr(struct heci_file_private *file,
1429 struct hbm_client_disconnect_request *disconn)
1430 {
1431 return ((file->host_client_id == disconn->host_addr)
1432 && (file->me_client_id == disconn->me_addr));
1433 }
1434
1435 /**
1436 * heci_client_disconnect_request - disconnect request bh routine
1437 *
1438 * @dev: Device object for our driver.
1439 * @disconnect_req: disconnect request bus message.
1440 */
1441 static void heci_client_disconnect_request(struct iamt_heci_device *dev,
1442 struct hbm_client_disconnect_request *disconnect_req)
1443 {
1444 struct heci_msg_hdr *heci_hdr;
1445 struct hbm_client_connect_response *disconnect_res;
1446 struct heci_file_private *file_pos = NULL;
1447 struct heci_file_private *file_next = NULL;
1448
1449 list_for_each_entry_safe(file_pos, file_next, &dev->file_list, link) {
1450 if (same_disconn_addr(file_pos, disconnect_req)) {
1451 DBG("disconnect request host client %d ME client %d.\n",
1452 disconnect_req->host_addr,
1453 disconnect_req->me_addr);
1454 file_pos->state = HECI_FILE_DISCONNECTED;
1455 file_pos->timer_count = 0;
1456 if (file_pos == &dev->wd_file_ext) {
1457 dev->wd_due_counter = 0;
1458 dev->wd_pending = 0;
1459 } else if (file_pos == &dev->iamthif_file_ext)
1460 dev->iamthif_timer = 0;
1461
1462 /* prepare disconnect response */
1463 heci_hdr =
1464 (struct heci_msg_hdr *) &dev->ext_msg_buf[0];
1465 heci_hdr->host_addr = 0;
1466 heci_hdr->me_addr = 0;
1467 heci_hdr->length =
1468 sizeof(struct hbm_client_connect_response);
1469 heci_hdr->msg_complete = 1;
1470 heci_hdr->reserved = 0;
1471
1472 disconnect_res =
1473 (struct hbm_client_connect_response *)
1474 &dev->ext_msg_buf[1];
1475 disconnect_res->host_addr = file_pos->host_client_id;
1476 disconnect_res->me_addr = file_pos->me_client_id;
1477 *(__u8 *) (&disconnect_res->cmd) =
1478 CLIENT_DISCONNECT_RES_CMD;
1479 disconnect_res->status = 0;
1480 dev->extra_write_index = 2;
1481 break;
1482 }
1483 }
1484 }
1485
1486 /**
1487 * heci_timer - timer function.
1488 *
1489 * @data: pointer to the device structure
1490 *
1491 * NOTE: This function is called by timer interrupt work
1492 */
1493 void heci_wd_timer(unsigned long data)
1494 {
1495 struct iamt_heci_device *dev = (struct iamt_heci_device *) data;
1496
1497 DBG("send watchdog.\n");
1498 spin_lock_bh(&dev->device_lock);
1499 if (dev->heci_state != HECI_ENABLED) {
1500 mod_timer(&dev->wd_timer, round_jiffies(jiffies + 2 * HZ));
1501 spin_unlock_bh(&dev->device_lock);
1502 return;
1503 }
1504 if (dev->wd_file_ext.state != HECI_FILE_CONNECTED) {
1505 mod_timer(&dev->wd_timer, round_jiffies(jiffies + 2 * HZ));
1506 spin_unlock_bh(&dev->device_lock);
1507 return;
1508 }
1509 /* Watchdog */
1510 if ((dev->wd_due_counter != 0) && (dev->wd_bypass == 0)) {
1511 if (--dev->wd_due_counter == 0) {
1512 if (dev->host_buffer_is_empty &&
1513 flow_ctrl_creds(dev, &dev->wd_file_ext)) {
1514 dev->host_buffer_is_empty = 0;
1515 if (!heci_send_wd(dev)) {
1516 DBG("wd send failed.\n");
1517 } else {
1518 flow_ctrl_reduce(dev,
1519 &dev->wd_file_ext);
1520 }
1521
1522 if (dev->wd_timeout != 0)
1523 dev->wd_due_counter = 2;
1524 else
1525 dev->wd_due_counter = 0;
1526
1527 } else
1528 dev->wd_pending = 1;
1529
1530 }
1531 }
1532 if (dev->iamthif_stall_timer != 0) {
1533 if (--dev->iamthif_stall_timer == 0) {
1534 DBG("reseting because of hang to PTHI.\n");
1535 heci_reset(dev, 1);
1536 dev->iamthif_msg_buf_size = 0;
1537 dev->iamthif_msg_buf_index = 0;
1538 dev->iamthif_canceled = 0;
1539 dev->iamthif_ioctl = 1;
1540 dev->iamthif_state = HECI_IAMTHIF_IDLE;
1541 dev->iamthif_timer = 0;
1542 spin_unlock_bh(&dev->device_lock);
1543
1544 if (dev->iamthif_current_cb)
1545 heci_free_cb_private(dev->iamthif_current_cb);
1546
1547 spin_lock_bh(&dev->device_lock);
1548 dev->iamthif_file_object = NULL;
1549 dev->iamthif_current_cb = NULL;
1550 run_next_iamthif_cmd(dev);
1551 }
1552 }
1553 mod_timer(&dev->wd_timer, round_jiffies(jiffies + 2 * HZ));
1554 spin_unlock_bh(&dev->device_lock);
1555 }
Linux with added FPC-III support