?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
net-next:asix: V2 Update VERSION
[zen-stable.git] / drivers / staging / tidspbridge / pmgr / dev.c
blob522810bc742738c35b12faea00f027d13ab96769
1 /*
2 * dev.c
3 *
4 * DSP-BIOS Bridge driver support functions for TI OMAP processors.
5 *
6 * Implementation of Bridge Bridge driver device operations.
7 *
8 * Copyright (C) 2005-2006 Texas Instruments, Inc.
9 *
10 * This package is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 *
14 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
16 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
17 */
18 #include <linux/types.h>
19 #include <linux/list.h>
20
21 /* ----------------------------------- Host OS */
22 #include <dspbridge/host_os.h>
23
24 /* ----------------------------------- DSP/BIOS Bridge */
25 #include <dspbridge/dbdefs.h>
26
27 /* ----------------------------------- Trace & Debug */
28 #include <dspbridge/dbc.h>
29
30 /* ----------------------------------- Platform Manager */
31 #include <dspbridge/cod.h>
32 #include <dspbridge/drv.h>
33 #include <dspbridge/proc.h>
34 #include <dspbridge/dmm.h>
35
36 /* ----------------------------------- Resource Manager */
37 #include <dspbridge/mgr.h>
38 #include <dspbridge/node.h>
39
40 /* ----------------------------------- Others */
41 #include <dspbridge/dspapi.h> /* DSP API version info. */
42
43 #include <dspbridge/chnl.h>
44 #include <dspbridge/io.h>
45 #include <dspbridge/msg.h>
46 #include <dspbridge/cmm.h>
47 #include <dspbridge/dspdeh.h>
48
49 /* ----------------------------------- This */
50 #include <dspbridge/dev.h>
51
52 /* ----------------------------------- Defines, Data Structures, Typedefs */
53
54 #define MAKEVERSION(major, minor) (major * 10 + minor)
55 #define BRD_API_VERSION MAKEVERSION(BRD_API_MAJOR_VERSION, \
56 BRD_API_MINOR_VERSION)
57
58 /* The Bridge device object: */
59 struct dev_object {
60 struct list_head link; /* Link to next dev_object. */
61 u8 dev_type; /* Device Type */
62 struct cfg_devnode *dev_node_obj; /* Platform specific dev id */
63 /* Bridge Context Handle */
64 struct bridge_dev_context *bridge_context;
65 /* Function interface to Bridge driver. */
66 struct bridge_drv_interface bridge_interface;
67 struct brd_object *lock_owner; /* Client with exclusive access. */
68 struct cod_manager *cod_mgr; /* Code manager handle. */
69 struct chnl_mgr *chnl_mgr; /* Channel manager. */
70 struct deh_mgr *deh_mgr; /* DEH manager. */
71 struct msg_mgr *msg_mgr; /* Message manager. */
72 struct io_mgr *iomgr; /* IO manager (CHNL, msg_ctrl) */
73 struct cmm_object *cmm_mgr; /* SM memory manager. */
74 struct dmm_object *dmm_mgr; /* Dynamic memory manager. */
75 u32 word_size; /* DSP word size: quick access. */
76 struct drv_object *drv_obj; /* Driver Object */
77 /* List of Processors attached to this device */
78 struct list_head proc_list;
79 struct node_mgr *node_mgr;
80 };
81
82 struct drv_ext {
83 struct list_head link;
84 char sz_string[MAXREGPATHLENGTH];
85 };
86
87 /* ----------------------------------- Globals */
88 static u32 refs; /* Module reference count */
89
90 /* ----------------------------------- Function Prototypes */
91 static int fxn_not_implemented(int arg, ...);
92 static int init_cod_mgr(struct dev_object *dev_obj);
93 static void store_interface_fxns(struct bridge_drv_interface *drv_fxns,
94 struct bridge_drv_interface *intf_fxns);
95 /*
96 * ======== dev_brd_write_fxn ========
97 * Purpose:
98 * Exported function to be used as the COD write function. This function
99 * is passed a handle to a DEV_hObject, then calls the
100 * device's bridge_brd_write() function.
101 */
102 u32 dev_brd_write_fxn(void *arb, u32 dsp_add, void *host_buf,
103 u32 ul_num_bytes, u32 mem_space)
104 {
105 struct dev_object *dev_obj = (struct dev_object *)arb;
106 u32 ul_written = 0;
107 int status;
108
109 DBC_REQUIRE(refs > 0);
110 DBC_REQUIRE(host_buf != NULL); /* Required of BrdWrite(). */
111 if (dev_obj) {
112 /* Require of BrdWrite() */
113 DBC_ASSERT(dev_obj->bridge_context != NULL);
114 status = (*dev_obj->bridge_interface.brd_write) (
115 dev_obj->bridge_context, host_buf,
116 dsp_add, ul_num_bytes, mem_space);
117 /* Special case of getting the address only */
118 if (ul_num_bytes == 0)
119 ul_num_bytes = 1;
120 if (!status)
121 ul_written = ul_num_bytes;
122
123 }
124 return ul_written;
125 }
126
127 /*
128 * ======== dev_create_device ========
129 * Purpose:
130 * Called by the operating system to load the PM Bridge Driver for a
131 * PM board (device).
132 */
133 int dev_create_device(struct dev_object **device_obj,
134 const char *driver_file_name,
135 struct cfg_devnode *dev_node_obj)
136 {
137 struct cfg_hostres *host_res;
138 struct bridge_drv_interface *drv_fxns = NULL;
139 struct dev_object *dev_obj = NULL;
140 struct chnl_mgrattrs mgr_attrs;
141 struct io_attrs io_mgr_attrs;
142 u32 num_windows;
143 struct drv_object *hdrv_obj = NULL;
144 struct drv_data *drv_datap = dev_get_drvdata(bridge);
145 int status = 0;
146 DBC_REQUIRE(refs > 0);
147 DBC_REQUIRE(device_obj != NULL);
148 DBC_REQUIRE(driver_file_name != NULL);
149
150 status = drv_request_bridge_res_dsp((void *)&host_res);
151
152 if (status) {
153 dev_dbg(bridge, "%s: Failed to reserve bridge resources\n",
154 __func__);
155 goto leave;
156 }
157
158 /* Get the Bridge driver interface functions */
159 bridge_drv_entry(&drv_fxns, driver_file_name);
160
161 /* Retrieve the Object handle from the driver data */
162 if (drv_datap && drv_datap->drv_object) {
163 hdrv_obj = drv_datap->drv_object;
164 } else {
165 status = -EPERM;
166 pr_err("%s: Failed to retrieve the object handle\n", __func__);
167 }
168
169 /* Create the device object, and pass a handle to the Bridge driver for
170 * storage. */
171 if (!status) {
172 DBC_ASSERT(drv_fxns);
173 dev_obj = kzalloc(sizeof(struct dev_object), GFP_KERNEL);
174 if (dev_obj) {
175 /* Fill out the rest of the Dev Object structure: */
176 dev_obj->dev_node_obj = dev_node_obj;
177 dev_obj->cod_mgr = NULL;
178 dev_obj->chnl_mgr = NULL;
179 dev_obj->deh_mgr = NULL;
180 dev_obj->lock_owner = NULL;
181 dev_obj->word_size = DSPWORDSIZE;
182 dev_obj->drv_obj = hdrv_obj;
183 dev_obj->dev_type = DSP_UNIT;
184 /* Store this Bridge's interface functions, based on its
185 * version. */
186 store_interface_fxns(drv_fxns,
187 &dev_obj->bridge_interface);
188
189 /* Call fxn_dev_create() to get the Bridge's device
190 * context handle. */
191 status = (dev_obj->bridge_interface.dev_create)
192 (&dev_obj->bridge_context, dev_obj,
193 host_res);
194 /* Assert bridge_dev_create()'s ensure clause: */
195 DBC_ASSERT(status
196 || (dev_obj->bridge_context != NULL));
197 } else {
198 status = -ENOMEM;
199 }
200 }
201 /* Attempt to create the COD manager for this device: */
202 if (!status)
203 status = init_cod_mgr(dev_obj);
204
205 /* Attempt to create the channel manager for this device: */
206 if (!status) {
207 mgr_attrs.max_channels = CHNL_MAXCHANNELS;
208 io_mgr_attrs.birq = host_res->birq_registers;
209 io_mgr_attrs.irq_shared =
210 (host_res->birq_attrib & CFG_IRQSHARED);
211 io_mgr_attrs.word_size = DSPWORDSIZE;
212 mgr_attrs.word_size = DSPWORDSIZE;
213 num_windows = host_res->num_mem_windows;
214 if (num_windows) {
215 /* Assume last memory window is for CHNL */
216 io_mgr_attrs.shm_base = host_res->mem_base[1] +
217 host_res->offset_for_monitor;
218 io_mgr_attrs.sm_length =
219 host_res->mem_length[1] -
220 host_res->offset_for_monitor;
221 } else {
222 io_mgr_attrs.shm_base = 0;
223 io_mgr_attrs.sm_length = 0;
224 pr_err("%s: No memory reserved for shared structures\n",
225 __func__);
226 }
227 status = chnl_create(&dev_obj->chnl_mgr, dev_obj, &mgr_attrs);
228 if (status == -ENOSYS) {
229 /* It's OK for a device not to have a channel
230 * manager: */
231 status = 0;
232 }
233 /* Create CMM mgr even if Msg Mgr not impl. */
234 status = cmm_create(&dev_obj->cmm_mgr,
235 (struct dev_object *)dev_obj, NULL);
236 /* Only create IO manager if we have a channel manager */
237 if (!status && dev_obj->chnl_mgr) {
238 status = io_create(&dev_obj->iomgr, dev_obj,
239 &io_mgr_attrs);
240 }
241 /* Only create DEH manager if we have an IO manager */
242 if (!status) {
243 /* Instantiate the DEH module */
244 status = bridge_deh_create(&dev_obj->deh_mgr, dev_obj);
245 }
246 /* Create DMM mgr . */
247 status = dmm_create(&dev_obj->dmm_mgr,
248 (struct dev_object *)dev_obj, NULL);
249 }
250 /* Add the new DEV_Object to the global list: */
251 if (!status)
252 status = drv_insert_dev_object(hdrv_obj, dev_obj);
253
254 /* Create the Processor List */
255 if (!status)
256 INIT_LIST_HEAD(&dev_obj->proc_list);
257 leave:
258 /* If all went well, return a handle to the dev object;
259 * else, cleanup and return NULL in the OUT parameter. */
260 if (!status) {
261 *device_obj = dev_obj;
262 } else {
263 if (dev_obj) {
264 if (dev_obj->cod_mgr)
265 cod_delete(dev_obj->cod_mgr);
266 if (dev_obj->dmm_mgr)
267 dmm_destroy(dev_obj->dmm_mgr);
268 kfree(dev_obj);
269 }
270
271 *device_obj = NULL;
272 }
273
274 DBC_ENSURE((!status && *device_obj) || (status && !*device_obj));
275 return status;
276 }
277
278 /*
279 * ======== dev_create2 ========
280 * Purpose:
281 * After successful loading of the image from api_init_complete2
282 * (PROC Auto_Start) or proc_load this fxn is called. This creates
283 * the Node Manager and updates the DEV Object.
284 */
285 int dev_create2(struct dev_object *hdev_obj)
286 {
287 int status = 0;
288 struct dev_object *dev_obj = hdev_obj;
289
290 DBC_REQUIRE(refs > 0);
291 DBC_REQUIRE(hdev_obj);
292
293 /* There can be only one Node Manager per DEV object */
294 DBC_ASSERT(!dev_obj->node_mgr);
295 status = node_create_mgr(&dev_obj->node_mgr, hdev_obj);
296 if (status)
297 dev_obj->node_mgr = NULL;
298
299 DBC_ENSURE((!status && dev_obj->node_mgr != NULL)
300 || (status && dev_obj->node_mgr == NULL));
301 return status;
302 }
303
304 /*
305 * ======== dev_destroy2 ========
306 * Purpose:
307 * Destroys the Node manager for this device.
308 */
309 int dev_destroy2(struct dev_object *hdev_obj)
310 {
311 int status = 0;
312 struct dev_object *dev_obj = hdev_obj;
313
314 DBC_REQUIRE(refs > 0);
315 DBC_REQUIRE(hdev_obj);
316
317 if (dev_obj->node_mgr) {
318 if (node_delete_mgr(dev_obj->node_mgr))
319 status = -EPERM;
320 else
321 dev_obj->node_mgr = NULL;
322
323 }
324
325 DBC_ENSURE((!status && dev_obj->node_mgr == NULL) || status);
326 return status;
327 }
328
329 /*
330 * ======== dev_destroy_device ========
331 * Purpose:
332 * Destroys the channel manager for this device, if any, calls
333 * bridge_dev_destroy(), and then attempts to unload the Bridge module.
334 */
335 int dev_destroy_device(struct dev_object *hdev_obj)
336 {
337 int status = 0;
338 struct dev_object *dev_obj = hdev_obj;
339
340 DBC_REQUIRE(refs > 0);
341
342 if (hdev_obj) {
343 if (dev_obj->cod_mgr) {
344 cod_delete(dev_obj->cod_mgr);
345 dev_obj->cod_mgr = NULL;
346 }
347
348 if (dev_obj->node_mgr) {
349 node_delete_mgr(dev_obj->node_mgr);
350 dev_obj->node_mgr = NULL;
351 }
352
353 /* Free the io, channel, and message managers for this board: */
354 if (dev_obj->iomgr) {
355 io_destroy(dev_obj->iomgr);
356 dev_obj->iomgr = NULL;
357 }
358 if (dev_obj->chnl_mgr) {
359 chnl_destroy(dev_obj->chnl_mgr);
360 dev_obj->chnl_mgr = NULL;
361 }
362 if (dev_obj->msg_mgr) {
363 msg_delete(dev_obj->msg_mgr);
364 dev_obj->msg_mgr = NULL;
365 }
366
367 if (dev_obj->deh_mgr) {
368 /* Uninitialize DEH module. */
369 bridge_deh_destroy(dev_obj->deh_mgr);
370 dev_obj->deh_mgr = NULL;
371 }
372 if (dev_obj->cmm_mgr) {
373 cmm_destroy(dev_obj->cmm_mgr, true);
374 dev_obj->cmm_mgr = NULL;
375 }
376
377 if (dev_obj->dmm_mgr) {
378 dmm_destroy(dev_obj->dmm_mgr);
379 dev_obj->dmm_mgr = NULL;
380 }
381
382 /* Call the driver's bridge_dev_destroy() function: */
383 /* Require of DevDestroy */
384 if (dev_obj->bridge_context) {
385 status = (*dev_obj->bridge_interface.dev_destroy)
386 (dev_obj->bridge_context);
387 dev_obj->bridge_context = NULL;
388 } else
389 status = -EPERM;
390 if (!status) {
391 /* Remove this DEV_Object from the global list: */
392 drv_remove_dev_object(dev_obj->drv_obj, dev_obj);
393 /* Free The library * LDR_FreeModule
394 * (dev_obj->module_obj); */
395 /* Free this dev object: */
396 kfree(dev_obj);
397 dev_obj = NULL;
398 }
399 } else {
400 status = -EFAULT;
401 }
402
403 return status;
404 }
405
406 /*
407 * ======== dev_get_chnl_mgr ========
408 * Purpose:
409 * Retrieve the handle to the channel manager handle created for this
410 * device.
411 */
412 int dev_get_chnl_mgr(struct dev_object *hdev_obj,
413 struct chnl_mgr **mgr)
414 {
415 int status = 0;
416 struct dev_object *dev_obj = hdev_obj;
417
418 DBC_REQUIRE(refs > 0);
419 DBC_REQUIRE(mgr != NULL);
420
421 if (hdev_obj) {
422 *mgr = dev_obj->chnl_mgr;
423 } else {
424 *mgr = NULL;
425 status = -EFAULT;
426 }
427
428 DBC_ENSURE(!status || (mgr != NULL && *mgr == NULL));
429 return status;
430 }
431
432 /*
433 * ======== dev_get_cmm_mgr ========
434 * Purpose:
435 * Retrieve the handle to the shared memory manager created for this
436 * device.
437 */
438 int dev_get_cmm_mgr(struct dev_object *hdev_obj,
439 struct cmm_object **mgr)
440 {
441 int status = 0;
442 struct dev_object *dev_obj = hdev_obj;
443
444 DBC_REQUIRE(refs > 0);
445 DBC_REQUIRE(mgr != NULL);
446
447 if (hdev_obj) {
448 *mgr = dev_obj->cmm_mgr;
449 } else {
450 *mgr = NULL;
451 status = -EFAULT;
452 }
453
454 DBC_ENSURE(!status || (mgr != NULL && *mgr == NULL));
455 return status;
456 }
457
458 /*
459 * ======== dev_get_dmm_mgr ========
460 * Purpose:
461 * Retrieve the handle to the dynamic memory manager created for this
462 * device.
463 */
464 int dev_get_dmm_mgr(struct dev_object *hdev_obj,
465 struct dmm_object **mgr)
466 {
467 int status = 0;
468 struct dev_object *dev_obj = hdev_obj;
469
470 DBC_REQUIRE(refs > 0);
471 DBC_REQUIRE(mgr != NULL);
472
473 if (hdev_obj) {
474 *mgr = dev_obj->dmm_mgr;
475 } else {
476 *mgr = NULL;
477 status = -EFAULT;
478 }
479
480 DBC_ENSURE(!status || (mgr != NULL && *mgr == NULL));
481 return status;
482 }
483
484 /*
485 * ======== dev_get_cod_mgr ========
486 * Purpose:
487 * Retrieve the COD manager create for this device.
488 */
489 int dev_get_cod_mgr(struct dev_object *hdev_obj,
490 struct cod_manager **cod_mgr)
491 {
492 int status = 0;
493 struct dev_object *dev_obj = hdev_obj;
494
495 DBC_REQUIRE(refs > 0);
496 DBC_REQUIRE(cod_mgr != NULL);
497
498 if (hdev_obj) {
499 *cod_mgr = dev_obj->cod_mgr;
500 } else {
501 *cod_mgr = NULL;
502 status = -EFAULT;
503 }
504
505 DBC_ENSURE(!status || (cod_mgr != NULL && *cod_mgr == NULL));
506 return status;
507 }
508
509 /*
510 * ========= dev_get_deh_mgr ========
511 */
512 int dev_get_deh_mgr(struct dev_object *hdev_obj,
513 struct deh_mgr **deh_manager)
514 {
515 int status = 0;
516
517 DBC_REQUIRE(refs > 0);
518 DBC_REQUIRE(deh_manager != NULL);
519 DBC_REQUIRE(hdev_obj);
520 if (hdev_obj) {
521 *deh_manager = hdev_obj->deh_mgr;
522 } else {
523 *deh_manager = NULL;
524 status = -EFAULT;
525 }
526 return status;
527 }
528
529 /*
530 * ======== dev_get_dev_node ========
531 * Purpose:
532 * Retrieve the platform specific device ID for this device.
533 */
534 int dev_get_dev_node(struct dev_object *hdev_obj,
535 struct cfg_devnode **dev_nde)
536 {
537 int status = 0;
538 struct dev_object *dev_obj = hdev_obj;
539
540 DBC_REQUIRE(refs > 0);
541 DBC_REQUIRE(dev_nde != NULL);
542
543 if (hdev_obj) {
544 *dev_nde = dev_obj->dev_node_obj;
545 } else {
546 *dev_nde = NULL;
547 status = -EFAULT;
548 }
549
550 DBC_ENSURE(!status || (dev_nde != NULL && *dev_nde == NULL));
551 return status;
552 }
553
554 /*
555 * ======== dev_get_first ========
556 * Purpose:
557 * Retrieve the first Device Object handle from an internal linked list
558 * DEV_OBJECTs maintained by DEV.
559 */
560 struct dev_object *dev_get_first(void)
561 {
562 struct dev_object *dev_obj = NULL;
563
564 dev_obj = (struct dev_object *)drv_get_first_dev_object();
565
566 return dev_obj;
567 }
568
569 /*
570 * ======== dev_get_intf_fxns ========
571 * Purpose:
572 * Retrieve the Bridge interface function structure for the loaded driver.
573 * if_fxns != NULL.
574 */
575 int dev_get_intf_fxns(struct dev_object *hdev_obj,
576 struct bridge_drv_interface **if_fxns)
577 {
578 int status = 0;
579 struct dev_object *dev_obj = hdev_obj;
580
581 DBC_REQUIRE(refs > 0);
582 DBC_REQUIRE(if_fxns != NULL);
583
584 if (hdev_obj) {
585 *if_fxns = &dev_obj->bridge_interface;
586 } else {
587 *if_fxns = NULL;
588 status = -EFAULT;
589 }
590
591 DBC_ENSURE(!status || ((if_fxns != NULL) && (*if_fxns == NULL)));
592 return status;
593 }
594
595 /*
596 * ========= dev_get_io_mgr ========
597 */
598 int dev_get_io_mgr(struct dev_object *hdev_obj,
599 struct io_mgr **io_man)
600 {
601 int status = 0;
602
603 DBC_REQUIRE(refs > 0);
604 DBC_REQUIRE(io_man != NULL);
605 DBC_REQUIRE(hdev_obj);
606
607 if (hdev_obj) {
608 *io_man = hdev_obj->iomgr;
609 } else {
610 *io_man = NULL;
611 status = -EFAULT;
612 }
613
614 return status;
615 }
616
617 /*
618 * ======== dev_get_next ========
619 * Purpose:
620 * Retrieve the next Device Object handle from an internal linked list
621 * of DEV_OBJECTs maintained by DEV, after having previously called
622 * dev_get_first() and zero or more dev_get_next
623 */
624 struct dev_object *dev_get_next(struct dev_object *hdev_obj)
625 {
626 struct dev_object *next_dev_object = NULL;
627
628 if (hdev_obj) {
629 next_dev_object = (struct dev_object *)
630 drv_get_next_dev_object((u32) hdev_obj);
631 }
632
633 return next_dev_object;
634 }
635
636 /*
637 * ========= dev_get_msg_mgr ========
638 */
639 void dev_get_msg_mgr(struct dev_object *hdev_obj, struct msg_mgr **msg_man)
640 {
641 DBC_REQUIRE(refs > 0);
642 DBC_REQUIRE(msg_man != NULL);
643 DBC_REQUIRE(hdev_obj);
644
645 *msg_man = hdev_obj->msg_mgr;
646 }
647
648 /*
649 * ======== dev_get_node_manager ========
650 * Purpose:
651 * Retrieve the Node Manager Handle
652 */
653 int dev_get_node_manager(struct dev_object *hdev_obj,
654 struct node_mgr **node_man)
655 {
656 int status = 0;
657 struct dev_object *dev_obj = hdev_obj;
658
659 DBC_REQUIRE(refs > 0);
660 DBC_REQUIRE(node_man != NULL);
661
662 if (hdev_obj) {
663 *node_man = dev_obj->node_mgr;
664 } else {
665 *node_man = NULL;
666 status = -EFAULT;
667 }
668
669 DBC_ENSURE(!status || (node_man != NULL && *node_man == NULL));
670 return status;
671 }
672
673 /*
674 * ======== dev_get_symbol ========
675 */
676 int dev_get_symbol(struct dev_object *hdev_obj,
677 const char *str_sym, u32 * pul_value)
678 {
679 int status = 0;
680 struct cod_manager *cod_mgr;
681
682 DBC_REQUIRE(refs > 0);
683 DBC_REQUIRE(str_sym != NULL && pul_value != NULL);
684
685 if (hdev_obj) {
686 status = dev_get_cod_mgr(hdev_obj, &cod_mgr);
687 if (cod_mgr)
688 status = cod_get_sym_value(cod_mgr, (char *)str_sym,
689 pul_value);
690 else
691 status = -EFAULT;
692 }
693
694 return status;
695 }
696
697 /*
698 * ======== dev_get_bridge_context ========
699 * Purpose:
700 * Retrieve the Bridge Context handle, as returned by the
701 * bridge_dev_create fxn.
702 */
703 int dev_get_bridge_context(struct dev_object *hdev_obj,
704 struct bridge_dev_context **phbridge_context)
705 {
706 int status = 0;
707 struct dev_object *dev_obj = hdev_obj;
708
709 DBC_REQUIRE(refs > 0);
710 DBC_REQUIRE(phbridge_context != NULL);
711
712 if (hdev_obj) {
713 *phbridge_context = dev_obj->bridge_context;
714 } else {
715 *phbridge_context = NULL;
716 status = -EFAULT;
717 }
718
719 DBC_ENSURE(!status || ((phbridge_context != NULL) &&
720 (*phbridge_context == NULL)));
721 return status;
722 }
723
724 /*
725 * ======== dev_exit ========
726 * Purpose:
727 * Decrement reference count, and free resources when reference count is
728 * 0.
729 */
730 void dev_exit(void)
731 {
732 DBC_REQUIRE(refs > 0);
733
734 refs--;
735
736 if (refs == 0) {
737 cmm_exit();
738 dmm_exit();
739 }
740
741 DBC_ENSURE(refs >= 0);
742 }
743
744 /*
745 * ======== dev_init ========
746 * Purpose:
747 * Initialize DEV's private state, keeping a reference count on each call.
748 */
749 bool dev_init(void)
750 {
751 bool cmm_ret, dmm_ret, ret = true;
752
753 DBC_REQUIRE(refs >= 0);
754
755 if (refs == 0) {
756 cmm_ret = cmm_init();
757 dmm_ret = dmm_init();
758
759 ret = cmm_ret && dmm_ret;
760
761 if (!ret) {
762 if (cmm_ret)
763 cmm_exit();
764
765 if (dmm_ret)
766 dmm_exit();
767
768 }
769 }
770
771 if (ret)
772 refs++;
773
774 DBC_ENSURE((ret && (refs > 0)) || (!ret && (refs >= 0)));
775
776 return ret;
777 }
778
779 /*
780 * ======== dev_notify_clients ========
781 * Purpose:
782 * Notify all clients of this device of a change in device status.
783 */
784 int dev_notify_clients(struct dev_object *dev_obj, u32 ret)
785 {
786 struct list_head *curr;
787
788 /*
789 * FIXME: this code needs struct proc_object to have a list_head
790 * at the beginning. If not, this can go horribly wrong.
791 */
792 list_for_each(curr, &dev_obj->proc_list)
793 proc_notify_clients((void *)curr, ret);
794
795 return 0;
796 }
797
798 /*
799 * ======== dev_remove_device ========
800 */
801 int dev_remove_device(struct cfg_devnode *dev_node_obj)
802 {
803 struct dev_object *hdev_obj; /* handle to device object */
804 int status = 0;
805 struct drv_data *drv_datap = dev_get_drvdata(bridge);
806
807 if (!drv_datap)
808 status = -ENODATA;
809
810 if (!dev_node_obj)
811 status = -EFAULT;
812
813 /* Retrieve the device object handle originally stored with
814 * the dev_node: */
815 if (!status) {
816 /* check the device string and then store dev object */
817 if (!strcmp((char *)((struct drv_ext *)dev_node_obj)->sz_string,
818 "TIOMAP1510")) {
819 hdev_obj = drv_datap->dev_object;
820 /* Destroy the device object. */
821 status = dev_destroy_device(hdev_obj);
822 } else {
823 status = -EPERM;
824 }
825 }
826
827 if (status)
828 pr_err("%s: Failed, status 0x%x\n", __func__, status);
829
830 return status;
831 }
832
833 /*
834 * ======== dev_set_chnl_mgr ========
835 * Purpose:
836 * Set the channel manager for this device.
837 */
838 int dev_set_chnl_mgr(struct dev_object *hdev_obj,
839 struct chnl_mgr *hmgr)
840 {
841 int status = 0;
842 struct dev_object *dev_obj = hdev_obj;
843
844 DBC_REQUIRE(refs > 0);
845
846 if (hdev_obj)
847 dev_obj->chnl_mgr = hmgr;
848 else
849 status = -EFAULT;
850
851 DBC_ENSURE(status || (dev_obj->chnl_mgr == hmgr));
852 return status;
853 }
854
855 /*
856 * ======== dev_set_msg_mgr ========
857 * Purpose:
858 * Set the message manager for this device.
859 */
860 void dev_set_msg_mgr(struct dev_object *hdev_obj, struct msg_mgr *hmgr)
861 {
862 DBC_REQUIRE(refs > 0);
863 DBC_REQUIRE(hdev_obj);
864
865 hdev_obj->msg_mgr = hmgr;
866 }
867
868 /*
869 * ======== dev_start_device ========
870 * Purpose:
871 * Initializes the new device with the BRIDGE environment.
872 */
873 int dev_start_device(struct cfg_devnode *dev_node_obj)
874 {
875 struct dev_object *hdev_obj = NULL; /* handle to 'Bridge Device */
876 /* Bridge driver filename */
877 char *bridge_file_name = "UMA";
878 int status;
879 struct mgr_object *hmgr_obj = NULL;
880 struct drv_data *drv_datap = dev_get_drvdata(bridge);
881
882 DBC_REQUIRE(refs > 0);
883
884 /* Given all resources, create a device object. */
885 status = dev_create_device(&hdev_obj, bridge_file_name,
886 dev_node_obj);
887 if (!status) {
888 /* Store away the hdev_obj with the DEVNODE */
889 if (!drv_datap || !dev_node_obj) {
890 status = -EFAULT;
891 pr_err("%s: Failed, status 0x%x\n", __func__, status);
892 } else if (!(strcmp((char *)dev_node_obj, "TIOMAP1510"))) {
893 drv_datap->dev_object = (void *) hdev_obj;
894 }
895 if (!status) {
896 /* Create the Manager Object */
897 status = mgr_create(&hmgr_obj, dev_node_obj);
898 if (status && !(strcmp((char *)dev_node_obj,
899 "TIOMAP1510"))) {
900 /* Ensure the device extension is NULL */
901 drv_datap->dev_object = NULL;
902 }
903 }
904 if (status) {
905 /* Clean up */
906 dev_destroy_device(hdev_obj);
907 hdev_obj = NULL;
908 }
909 }
910
911 return status;
912 }
913
914 /*
915 * ======== fxn_not_implemented ========
916 * Purpose:
917 * Takes the place of a Bridge Null Function.
918 * Parameters:
919 * Multiple, optional.
920 * Returns:
921 * -ENOSYS: Always.
922 */
923 static int fxn_not_implemented(int arg, ...)
924 {
925 return -ENOSYS;
926 }
927
928 /*
929 * ======== init_cod_mgr ========
930 * Purpose:
931 * Create a COD manager for this device.
932 * Parameters:
933 * dev_obj: Pointer to device object created with
934 * dev_create_device()
935 * Returns:
936 * 0: Success.
937 * -EFAULT: Invalid hdev_obj.
938 * Requires:
939 * Should only be called once by dev_create_device() for a given DevObject.
940 * Ensures:
941 */
942 static int init_cod_mgr(struct dev_object *dev_obj)
943 {
944 int status = 0;
945 char *sz_dummy_file = "dummy";
946
947 DBC_REQUIRE(refs > 0);
948 DBC_REQUIRE(!dev_obj || (dev_obj->cod_mgr == NULL));
949
950 status = cod_create(&dev_obj->cod_mgr, sz_dummy_file);
951
952 return status;
953 }
954
955 /*
956 * ======== dev_insert_proc_object ========
957 * Purpose:
958 * Insert a ProcObject into the list maintained by DEV.
959 * Parameters:
960 * p_proc_object: Ptr to ProcObject to insert.
961 * dev_obj: Ptr to Dev Object where the list is.
962 * already_attached: Ptr to return the bool
963 * Returns:
964 * 0: If successful.
965 * Requires:
966 * List Exists
967 * hdev_obj is Valid handle
968 * DEV Initialized
969 * already_attached != NULL
970 * proc_obj != 0
971 * Ensures:
972 * 0 and List is not Empty.
973 */
974 int dev_insert_proc_object(struct dev_object *hdev_obj,
975 u32 proc_obj, bool *already_attached)
976 {
977 struct dev_object *dev_obj = (struct dev_object *)hdev_obj;
978
979 DBC_REQUIRE(refs > 0);
980 DBC_REQUIRE(dev_obj);
981 DBC_REQUIRE(proc_obj != 0);
982 DBC_REQUIRE(already_attached != NULL);
983 if (!list_empty(&dev_obj->proc_list))
984 *already_attached = true;
985
986 /* Add DevObject to tail. */
987 /*
988 * FIXME: this code needs struct proc_object to have a list_head
989 * at the beginning. If not, this can go horribly wrong.
990 */
991 list_add_tail((struct list_head *)proc_obj, &dev_obj->proc_list);
992
993 return 0;
994 }
995
996 /*
997 * ======== dev_remove_proc_object ========
998 * Purpose:
999 * Search for and remove a Proc object from the given list maintained
1000 * by the DEV
1001 * Parameters:
1002 * p_proc_object: Ptr to ProcObject to insert.
1003 * dev_obj Ptr to Dev Object where the list is.
1004 * Returns:
1005 * 0: If successful.
1006 * Requires:
1007 * List exists and is not empty
1008 * proc_obj != 0
1009 * hdev_obj is a valid Dev handle.
1010 * Ensures:
1011 * Details:
1012 * List will be deleted when the DEV is destroyed.
1013 */
1014 int dev_remove_proc_object(struct dev_object *hdev_obj, u32 proc_obj)
1015 {
1016 int status = -EPERM;
1017 struct list_head *cur_elem;
1018 struct dev_object *dev_obj = (struct dev_object *)hdev_obj;
1019
1020 DBC_REQUIRE(dev_obj);
1021 DBC_REQUIRE(proc_obj != 0);
1022 DBC_REQUIRE(!list_empty(&dev_obj->proc_list));
1023
1024 /* Search list for dev_obj: */
1025 list_for_each(cur_elem, &dev_obj->proc_list) {
1026 if ((u32) cur_elem == proc_obj) {
1027 list_del(cur_elem);
1028 status = 0;
1029 break;
1030 }
1031 }
1032
1033 return status;
1034 }
1035
1036 int dev_get_dev_type(struct dev_object *dev_obj, u8 *dev_type)
1037 {
1038 *dev_type = dev_obj->dev_type;
1039 return 0;
1040 }
1041
1042 /*
1043 * ======== store_interface_fxns ========
1044 * Purpose:
1045 * Copy the Bridge's interface functions into the device object,
1046 * ensuring that fxn_not_implemented() is set for:
1047 *
1048 * 1. All Bridge function pointers which are NULL; and
1049 * 2. All function slots in the struct dev_object structure which have no
1050 * corresponding slots in the the Bridge's interface, because the Bridge
1051 * is of an *older* version.
1052 * Parameters:
1053 * intf_fxns: Interface fxn Structure of the Bridge's Dev Object.
1054 * drv_fxns: Interface Fxns offered by the Bridge during DEV_Create().
1055 * Returns:
1056 * Requires:
1057 * Input pointers are valid.
1058 * Bridge driver is *not* written for a newer DSP API.
1059 * Ensures:
1060 * All function pointers in the dev object's fxn interface are not NULL.
1061 */
1062 static void store_interface_fxns(struct bridge_drv_interface *drv_fxns,
1063 struct bridge_drv_interface *intf_fxns)
1064 {
1065 u32 bridge_version;
1066
1067 /* Local helper macro: */
1068 #define STORE_FXN(cast, pfn) \
1069 (intf_fxns->pfn = ((drv_fxns->pfn != NULL) ? drv_fxns->pfn : \
1070 (cast)fxn_not_implemented))
1071
1072 DBC_REQUIRE(intf_fxns != NULL);
1073 DBC_REQUIRE(drv_fxns != NULL);
1074 DBC_REQUIRE(MAKEVERSION(drv_fxns->brd_api_major_version,
1075 drv_fxns->brd_api_minor_version) <= BRD_API_VERSION);
1076 bridge_version = MAKEVERSION(drv_fxns->brd_api_major_version,
1077 drv_fxns->brd_api_minor_version);
1078 intf_fxns->brd_api_major_version = drv_fxns->brd_api_major_version;
1079 intf_fxns->brd_api_minor_version = drv_fxns->brd_api_minor_version;
1080 /* Install functions up to DSP API version .80 (first alpha): */
1081 if (bridge_version > 0) {
1082 STORE_FXN(fxn_dev_create, dev_create);
1083 STORE_FXN(fxn_dev_destroy, dev_destroy);
1084 STORE_FXN(fxn_dev_ctrl, dev_cntrl);
1085 STORE_FXN(fxn_brd_monitor, brd_monitor);
1086 STORE_FXN(fxn_brd_start, brd_start);
1087 STORE_FXN(fxn_brd_stop, brd_stop);
1088 STORE_FXN(fxn_brd_status, brd_status);
1089 STORE_FXN(fxn_brd_read, brd_read);
1090 STORE_FXN(fxn_brd_write, brd_write);
1091 STORE_FXN(fxn_brd_setstate, brd_set_state);
1092 STORE_FXN(fxn_brd_memcopy, brd_mem_copy);
1093 STORE_FXN(fxn_brd_memwrite, brd_mem_write);
1094 STORE_FXN(fxn_brd_memmap, brd_mem_map);
1095 STORE_FXN(fxn_brd_memunmap, brd_mem_un_map);
1096 STORE_FXN(fxn_chnl_create, chnl_create);
1097 STORE_FXN(fxn_chnl_destroy, chnl_destroy);
1098 STORE_FXN(fxn_chnl_open, chnl_open);
1099 STORE_FXN(fxn_chnl_close, chnl_close);
1100 STORE_FXN(fxn_chnl_addioreq, chnl_add_io_req);
1101 STORE_FXN(fxn_chnl_getioc, chnl_get_ioc);
1102 STORE_FXN(fxn_chnl_cancelio, chnl_cancel_io);
1103 STORE_FXN(fxn_chnl_flushio, chnl_flush_io);
1104 STORE_FXN(fxn_chnl_getinfo, chnl_get_info);
1105 STORE_FXN(fxn_chnl_getmgrinfo, chnl_get_mgr_info);
1106 STORE_FXN(fxn_chnl_idle, chnl_idle);
1107 STORE_FXN(fxn_chnl_registernotify, chnl_register_notify);
1108 STORE_FXN(fxn_io_create, io_create);
1109 STORE_FXN(fxn_io_destroy, io_destroy);
1110 STORE_FXN(fxn_io_onloaded, io_on_loaded);
1111 STORE_FXN(fxn_io_getprocload, io_get_proc_load);
1112 STORE_FXN(fxn_msg_create, msg_create);
1113 STORE_FXN(fxn_msg_createqueue, msg_create_queue);
1114 STORE_FXN(fxn_msg_delete, msg_delete);
1115 STORE_FXN(fxn_msg_deletequeue, msg_delete_queue);
1116 STORE_FXN(fxn_msg_get, msg_get);
1117 STORE_FXN(fxn_msg_put, msg_put);
1118 STORE_FXN(fxn_msg_registernotify, msg_register_notify);
1119 STORE_FXN(fxn_msg_setqueueid, msg_set_queue_id);
1120 }
1121 /* Add code for any additional functions in newerBridge versions here */
1122 /* Ensure postcondition: */
1123 DBC_ENSURE(intf_fxns->dev_create != NULL);
1124 DBC_ENSURE(intf_fxns->dev_destroy != NULL);
1125 DBC_ENSURE(intf_fxns->dev_cntrl != NULL);
1126 DBC_ENSURE(intf_fxns->brd_monitor != NULL);
1127 DBC_ENSURE(intf_fxns->brd_start != NULL);
1128 DBC_ENSURE(intf_fxns->brd_stop != NULL);
1129 DBC_ENSURE(intf_fxns->brd_status != NULL);
1130 DBC_ENSURE(intf_fxns->brd_read != NULL);
1131 DBC_ENSURE(intf_fxns->brd_write != NULL);
1132 DBC_ENSURE(intf_fxns->chnl_create != NULL);
1133 DBC_ENSURE(intf_fxns->chnl_destroy != NULL);
1134 DBC_ENSURE(intf_fxns->chnl_open != NULL);
1135 DBC_ENSURE(intf_fxns->chnl_close != NULL);
1136 DBC_ENSURE(intf_fxns->chnl_add_io_req != NULL);
1137 DBC_ENSURE(intf_fxns->chnl_get_ioc != NULL);
1138 DBC_ENSURE(intf_fxns->chnl_cancel_io != NULL);
1139 DBC_ENSURE(intf_fxns->chnl_flush_io != NULL);
1140 DBC_ENSURE(intf_fxns->chnl_get_info != NULL);
1141 DBC_ENSURE(intf_fxns->chnl_get_mgr_info != NULL);
1142 DBC_ENSURE(intf_fxns->chnl_idle != NULL);
1143 DBC_ENSURE(intf_fxns->chnl_register_notify != NULL);
1144 DBC_ENSURE(intf_fxns->io_create != NULL);
1145 DBC_ENSURE(intf_fxns->io_destroy != NULL);
1146 DBC_ENSURE(intf_fxns->io_on_loaded != NULL);
1147 DBC_ENSURE(intf_fxns->io_get_proc_load != NULL);
1148 DBC_ENSURE(intf_fxns->msg_set_queue_id != NULL);
1149
1150 #undef STORE_FXN
1151 }