smscoreapi.c 34 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342
  1. /*
  2. * Siano core API module
  3. *
  4. * This file contains implementation for the interface to sms core component
  5. *
  6. * author: Uri Shkolnik
  7. *
  8. * Copyright (c), 2005-2008 Siano Mobile Silicon, Inc.
  9. *
  10. * This program 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. * Software distributed under the License is distributed on an "AS IS"
  15. * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
  16. *
  17. * See the GNU General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU General Public License
  20. * along with this program; if not, write to the Free Software
  21. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22. */
  23. #include <linux/kernel.h>
  24. #include <linux/init.h>
  25. #include <linux/module.h>
  26. #include <linux/moduleparam.h>
  27. #include <linux/dma-mapping.h>
  28. #include <linux/delay.h>
  29. #include <linux/io.h>
  30. #include <linux/firmware.h>
  31. #include "smscoreapi.h"
  32. #include "sms-cards.h"
  33. static int sms_dbg;
  34. module_param_named(debug, sms_dbg, int, 0644);
  35. MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))");
  36. struct smscore_device_notifyee_t {
  37. struct list_head entry;
  38. hotplug_t hotplug;
  39. };
  40. struct smscore_idlist_t {
  41. struct list_head entry;
  42. int id;
  43. int data_type;
  44. };
  45. struct smscore_client_t {
  46. struct list_head entry;
  47. struct smscore_device_t *coredev;
  48. void *context;
  49. struct list_head idlist;
  50. onresponse_t onresponse_handler;
  51. onremove_t onremove_handler;
  52. };
  53. struct smscore_device_t {
  54. struct list_head entry;
  55. struct list_head clients;
  56. struct list_head subclients;
  57. spinlock_t clientslock;
  58. struct list_head buffers;
  59. spinlock_t bufferslock;
  60. int num_buffers;
  61. void *common_buffer;
  62. int common_buffer_size;
  63. dma_addr_t common_buffer_phys;
  64. void *context;
  65. struct device *device;
  66. char devpath[32];
  67. unsigned long device_flags;
  68. setmode_t setmode_handler;
  69. detectmode_t detectmode_handler;
  70. sendrequest_t sendrequest_handler;
  71. preload_t preload_handler;
  72. postload_t postload_handler;
  73. int mode, modes_supported;
  74. struct completion version_ex_done, data_download_done, trigger_done;
  75. struct completion init_device_done, reload_start_done, resume_done;
  76. int board_id;
  77. int led_state;
  78. };
  79. void smscore_set_board_id(struct smscore_device_t *core, int id)
  80. {
  81. core->board_id = id;
  82. }
  83. int smscore_led_state(struct smscore_device_t *core, int led)
  84. {
  85. if (led >= 0)
  86. core->led_state = led;
  87. return core->led_state;
  88. }
  89. EXPORT_SYMBOL_GPL(smscore_set_board_id);
  90. int smscore_get_board_id(struct smscore_device_t *core)
  91. {
  92. return core->board_id;
  93. }
  94. EXPORT_SYMBOL_GPL(smscore_get_board_id);
  95. struct smscore_registry_entry_t {
  96. struct list_head entry;
  97. char devpath[32];
  98. int mode;
  99. enum sms_device_type_st type;
  100. };
  101. static struct list_head g_smscore_notifyees;
  102. static struct list_head g_smscore_devices;
  103. static struct mutex g_smscore_deviceslock;
  104. static struct list_head g_smscore_registry;
  105. static struct mutex g_smscore_registrylock;
  106. static int default_mode = 4;
  107. module_param(default_mode, int, 0644);
  108. MODULE_PARM_DESC(default_mode, "default firmware id (device mode)");
  109. static struct smscore_registry_entry_t *smscore_find_registry(char *devpath)
  110. {
  111. struct smscore_registry_entry_t *entry;
  112. struct list_head *next;
  113. kmutex_lock(&g_smscore_registrylock);
  114. for (next = g_smscore_registry.next;
  115. next != &g_smscore_registry;
  116. next = next->next) {
  117. entry = (struct smscore_registry_entry_t *) next;
  118. if (!strcmp(entry->devpath, devpath)) {
  119. kmutex_unlock(&g_smscore_registrylock);
  120. return entry;
  121. }
  122. }
  123. entry = (struct smscore_registry_entry_t *)
  124. kmalloc(sizeof(struct smscore_registry_entry_t),
  125. GFP_KERNEL);
  126. if (entry) {
  127. entry->mode = default_mode;
  128. strcpy(entry->devpath, devpath);
  129. list_add(&entry->entry, &g_smscore_registry);
  130. } else
  131. sms_err("failed to create smscore_registry.");
  132. kmutex_unlock(&g_smscore_registrylock);
  133. return entry;
  134. }
  135. int smscore_registry_getmode(char *devpath)
  136. {
  137. struct smscore_registry_entry_t *entry;
  138. entry = smscore_find_registry(devpath);
  139. if (entry)
  140. return entry->mode;
  141. else
  142. sms_err("No registry found.");
  143. return default_mode;
  144. }
  145. EXPORT_SYMBOL_GPL(smscore_registry_getmode);
  146. static enum sms_device_type_st smscore_registry_gettype(char *devpath)
  147. {
  148. struct smscore_registry_entry_t *entry;
  149. entry = smscore_find_registry(devpath);
  150. if (entry)
  151. return entry->type;
  152. else
  153. sms_err("No registry found.");
  154. return -1;
  155. }
  156. void smscore_registry_setmode(char *devpath, int mode)
  157. {
  158. struct smscore_registry_entry_t *entry;
  159. entry = smscore_find_registry(devpath);
  160. if (entry)
  161. entry->mode = mode;
  162. else
  163. sms_err("No registry found.");
  164. }
  165. static void smscore_registry_settype(char *devpath,
  166. enum sms_device_type_st type)
  167. {
  168. struct smscore_registry_entry_t *entry;
  169. entry = smscore_find_registry(devpath);
  170. if (entry)
  171. entry->type = type;
  172. else
  173. sms_err("No registry found.");
  174. }
  175. static void list_add_locked(struct list_head *new, struct list_head *head,
  176. spinlock_t *lock)
  177. {
  178. unsigned long flags;
  179. spin_lock_irqsave(lock, flags);
  180. list_add(new, head);
  181. spin_unlock_irqrestore(lock, flags);
  182. }
  183. /**
  184. * register a client callback that called when device plugged in/unplugged
  185. * NOTE: if devices exist callback is called immediately for each device
  186. *
  187. * @param hotplug callback
  188. *
  189. * @return 0 on success, <0 on error.
  190. */
  191. int smscore_register_hotplug(hotplug_t hotplug)
  192. {
  193. struct smscore_device_notifyee_t *notifyee;
  194. struct list_head *next, *first;
  195. int rc = 0;
  196. kmutex_lock(&g_smscore_deviceslock);
  197. notifyee = kmalloc(sizeof(struct smscore_device_notifyee_t),
  198. GFP_KERNEL);
  199. if (notifyee) {
  200. /* now notify callback about existing devices */
  201. first = &g_smscore_devices;
  202. for (next = first->next;
  203. next != first && !rc;
  204. next = next->next) {
  205. struct smscore_device_t *coredev =
  206. (struct smscore_device_t *) next;
  207. rc = hotplug(coredev, coredev->device, 1);
  208. }
  209. if (rc >= 0) {
  210. notifyee->hotplug = hotplug;
  211. list_add(&notifyee->entry, &g_smscore_notifyees);
  212. } else
  213. kfree(notifyee);
  214. } else
  215. rc = -ENOMEM;
  216. kmutex_unlock(&g_smscore_deviceslock);
  217. return rc;
  218. }
  219. EXPORT_SYMBOL_GPL(smscore_register_hotplug);
  220. /**
  221. * unregister a client callback that called when device plugged in/unplugged
  222. *
  223. * @param hotplug callback
  224. *
  225. */
  226. void smscore_unregister_hotplug(hotplug_t hotplug)
  227. {
  228. struct list_head *next, *first;
  229. kmutex_lock(&g_smscore_deviceslock);
  230. first = &g_smscore_notifyees;
  231. for (next = first->next; next != first;) {
  232. struct smscore_device_notifyee_t *notifyee =
  233. (struct smscore_device_notifyee_t *) next;
  234. next = next->next;
  235. if (notifyee->hotplug == hotplug) {
  236. list_del(&notifyee->entry);
  237. kfree(notifyee);
  238. }
  239. }
  240. kmutex_unlock(&g_smscore_deviceslock);
  241. }
  242. EXPORT_SYMBOL_GPL(smscore_unregister_hotplug);
  243. static void smscore_notify_clients(struct smscore_device_t *coredev)
  244. {
  245. struct smscore_client_t *client;
  246. /* the client must call smscore_unregister_client from remove handler */
  247. while (!list_empty(&coredev->clients)) {
  248. client = (struct smscore_client_t *) coredev->clients.next;
  249. client->onremove_handler(client->context);
  250. }
  251. }
  252. static int smscore_notify_callbacks(struct smscore_device_t *coredev,
  253. struct device *device, int arrival)
  254. {
  255. struct list_head *next, *first;
  256. int rc = 0;
  257. /* note: must be called under g_deviceslock */
  258. first = &g_smscore_notifyees;
  259. for (next = first->next; next != first; next = next->next) {
  260. rc = ((struct smscore_device_notifyee_t *) next)->
  261. hotplug(coredev, device, arrival);
  262. if (rc < 0)
  263. break;
  264. }
  265. return rc;
  266. }
  267. static struct
  268. smscore_buffer_t *smscore_createbuffer(u8 *buffer, void *common_buffer,
  269. dma_addr_t common_buffer_phys)
  270. {
  271. struct smscore_buffer_t *cb =
  272. kmalloc(sizeof(struct smscore_buffer_t), GFP_KERNEL);
  273. if (!cb) {
  274. sms_info("kmalloc(...) failed");
  275. return NULL;
  276. }
  277. cb->p = buffer;
  278. cb->offset_in_common = buffer - (u8 *) common_buffer;
  279. cb->phys = common_buffer_phys + cb->offset_in_common;
  280. return cb;
  281. }
  282. /**
  283. * creates coredev object for a device, prepares buffers,
  284. * creates buffer mappings, notifies registered hotplugs about new device.
  285. *
  286. * @param params device pointer to struct with device specific parameters
  287. * and handlers
  288. * @param coredev pointer to a value that receives created coredev object
  289. *
  290. * @return 0 on success, <0 on error.
  291. */
  292. int smscore_register_device(struct smsdevice_params_t *params,
  293. struct smscore_device_t **coredev)
  294. {
  295. struct smscore_device_t *dev;
  296. u8 *buffer;
  297. dev = kzalloc(sizeof(struct smscore_device_t), GFP_KERNEL);
  298. if (!dev) {
  299. sms_info("kzalloc(...) failed");
  300. return -ENOMEM;
  301. }
  302. /* init list entry so it could be safe in smscore_unregister_device */
  303. INIT_LIST_HEAD(&dev->entry);
  304. /* init queues */
  305. INIT_LIST_HEAD(&dev->clients);
  306. INIT_LIST_HEAD(&dev->buffers);
  307. /* init locks */
  308. spin_lock_init(&dev->clientslock);
  309. spin_lock_init(&dev->bufferslock);
  310. /* init completion events */
  311. init_completion(&dev->version_ex_done);
  312. init_completion(&dev->data_download_done);
  313. init_completion(&dev->trigger_done);
  314. init_completion(&dev->init_device_done);
  315. init_completion(&dev->reload_start_done);
  316. init_completion(&dev->resume_done);
  317. /* alloc common buffer */
  318. dev->common_buffer_size = params->buffer_size * params->num_buffers;
  319. dev->common_buffer = dma_alloc_coherent(NULL, dev->common_buffer_size,
  320. &dev->common_buffer_phys,
  321. GFP_KERNEL | GFP_DMA);
  322. if (!dev->common_buffer) {
  323. smscore_unregister_device(dev);
  324. return -ENOMEM;
  325. }
  326. /* prepare dma buffers */
  327. for (buffer = dev->common_buffer;
  328. dev->num_buffers < params->num_buffers;
  329. dev->num_buffers++, buffer += params->buffer_size) {
  330. struct smscore_buffer_t *cb =
  331. smscore_createbuffer(buffer, dev->common_buffer,
  332. dev->common_buffer_phys);
  333. if (!cb) {
  334. smscore_unregister_device(dev);
  335. return -ENOMEM;
  336. }
  337. smscore_putbuffer(dev, cb);
  338. }
  339. sms_info("allocated %d buffers", dev->num_buffers);
  340. dev->mode = DEVICE_MODE_NONE;
  341. dev->context = params->context;
  342. dev->device = params->device;
  343. dev->setmode_handler = params->setmode_handler;
  344. dev->detectmode_handler = params->detectmode_handler;
  345. dev->sendrequest_handler = params->sendrequest_handler;
  346. dev->preload_handler = params->preload_handler;
  347. dev->postload_handler = params->postload_handler;
  348. dev->device_flags = params->flags;
  349. strcpy(dev->devpath, params->devpath);
  350. smscore_registry_settype(dev->devpath, params->device_type);
  351. /* add device to devices list */
  352. kmutex_lock(&g_smscore_deviceslock);
  353. list_add(&dev->entry, &g_smscore_devices);
  354. kmutex_unlock(&g_smscore_deviceslock);
  355. *coredev = dev;
  356. sms_info("device %p created", dev);
  357. return 0;
  358. }
  359. EXPORT_SYMBOL_GPL(smscore_register_device);
  360. /**
  361. * sets initial device mode and notifies client hotplugs that device is ready
  362. *
  363. * @param coredev pointer to a coredev object returned by
  364. * smscore_register_device
  365. *
  366. * @return 0 on success, <0 on error.
  367. */
  368. int smscore_start_device(struct smscore_device_t *coredev)
  369. {
  370. int rc = smscore_set_device_mode(
  371. coredev, smscore_registry_getmode(coredev->devpath));
  372. if (rc < 0) {
  373. sms_info("set device mode faile , rc %d", rc);
  374. return rc;
  375. }
  376. kmutex_lock(&g_smscore_deviceslock);
  377. rc = smscore_notify_callbacks(coredev, coredev->device, 1);
  378. sms_info("device %p started, rc %d", coredev, rc);
  379. kmutex_unlock(&g_smscore_deviceslock);
  380. return rc;
  381. }
  382. EXPORT_SYMBOL_GPL(smscore_start_device);
  383. static int smscore_sendrequest_and_wait(struct smscore_device_t *coredev,
  384. void *buffer, size_t size,
  385. struct completion *completion)
  386. {
  387. int rc = coredev->sendrequest_handler(coredev->context, buffer, size);
  388. if (rc < 0) {
  389. sms_info("sendrequest returned error %d", rc);
  390. return rc;
  391. }
  392. return wait_for_completion_timeout(completion,
  393. msecs_to_jiffies(10000)) ?
  394. 0 : -ETIME;
  395. }
  396. static int smscore_load_firmware_family2(struct smscore_device_t *coredev,
  397. void *buffer, size_t size)
  398. {
  399. struct SmsFirmware_ST *firmware = (struct SmsFirmware_ST *) buffer;
  400. struct SmsMsgHdr_ST *msg;
  401. u32 mem_address = firmware->StartAddress;
  402. u8 *payload = firmware->Payload;
  403. int rc = 0;
  404. sms_info("loading FW to addr 0x%x size %d",
  405. mem_address, firmware->Length);
  406. if (coredev->preload_handler) {
  407. rc = coredev->preload_handler(coredev->context);
  408. if (rc < 0)
  409. return rc;
  410. }
  411. /* PAGE_SIZE buffer shall be enough and dma aligned */
  412. msg = kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA);
  413. if (!msg)
  414. return -ENOMEM;
  415. if (coredev->mode != DEVICE_MODE_NONE) {
  416. sms_debug("sending reload command.");
  417. SMS_INIT_MSG(msg, MSG_SW_RELOAD_START_REQ,
  418. sizeof(struct SmsMsgHdr_ST));
  419. rc = smscore_sendrequest_and_wait(coredev, msg,
  420. msg->msgLength,
  421. &coredev->reload_start_done);
  422. mem_address = *(u32 *) &payload[20];
  423. }
  424. while (size && rc >= 0) {
  425. struct SmsDataDownload_ST *DataMsg =
  426. (struct SmsDataDownload_ST *) msg;
  427. int payload_size = min((int) size, SMS_MAX_PAYLOAD_SIZE);
  428. SMS_INIT_MSG(msg, MSG_SMS_DATA_DOWNLOAD_REQ,
  429. (u16)(sizeof(struct SmsMsgHdr_ST) +
  430. sizeof(u32) + payload_size));
  431. DataMsg->MemAddr = mem_address;
  432. memcpy(DataMsg->Payload, payload, payload_size);
  433. if ((coredev->device_flags & SMS_ROM_NO_RESPONSE) &&
  434. (coredev->mode == DEVICE_MODE_NONE))
  435. rc = coredev->sendrequest_handler(
  436. coredev->context, DataMsg,
  437. DataMsg->xMsgHeader.msgLength);
  438. else
  439. rc = smscore_sendrequest_and_wait(
  440. coredev, DataMsg,
  441. DataMsg->xMsgHeader.msgLength,
  442. &coredev->data_download_done);
  443. payload += payload_size;
  444. size -= payload_size;
  445. mem_address += payload_size;
  446. }
  447. if (rc >= 0) {
  448. if (coredev->mode == DEVICE_MODE_NONE) {
  449. struct SmsMsgData_ST *TriggerMsg =
  450. (struct SmsMsgData_ST *) msg;
  451. SMS_INIT_MSG(msg, MSG_SMS_SWDOWNLOAD_TRIGGER_REQ,
  452. sizeof(struct SmsMsgHdr_ST) +
  453. sizeof(u32) * 5);
  454. TriggerMsg->msgData[0] = firmware->StartAddress;
  455. /* Entry point */
  456. TriggerMsg->msgData[1] = 5; /* Priority */
  457. TriggerMsg->msgData[2] = 0x200; /* Stack size */
  458. TriggerMsg->msgData[3] = 0; /* Parameter */
  459. TriggerMsg->msgData[4] = 4; /* Task ID */
  460. if (coredev->device_flags & SMS_ROM_NO_RESPONSE) {
  461. rc = coredev->sendrequest_handler(
  462. coredev->context, TriggerMsg,
  463. TriggerMsg->xMsgHeader.msgLength);
  464. msleep(100);
  465. } else
  466. rc = smscore_sendrequest_and_wait(
  467. coredev, TriggerMsg,
  468. TriggerMsg->xMsgHeader.msgLength,
  469. &coredev->trigger_done);
  470. } else {
  471. SMS_INIT_MSG(msg, MSG_SW_RELOAD_EXEC_REQ,
  472. sizeof(struct SmsMsgHdr_ST));
  473. rc = coredev->sendrequest_handler(coredev->context,
  474. msg, msg->msgLength);
  475. }
  476. msleep(500);
  477. }
  478. sms_debug("rc=%d, postload=%p ", rc,
  479. coredev->postload_handler);
  480. kfree(msg);
  481. return ((rc >= 0) && coredev->postload_handler) ?
  482. coredev->postload_handler(coredev->context) :
  483. rc;
  484. }
  485. /**
  486. * loads specified firmware into a buffer and calls device loadfirmware_handler
  487. *
  488. * @param coredev pointer to a coredev object returned by
  489. * smscore_register_device
  490. * @param filename null-terminated string specifies firmware file name
  491. * @param loadfirmware_handler device handler that loads firmware
  492. *
  493. * @return 0 on success, <0 on error.
  494. */
  495. static int smscore_load_firmware_from_file(struct smscore_device_t *coredev,
  496. char *filename,
  497. loadfirmware_t loadfirmware_handler)
  498. {
  499. int rc = -ENOENT;
  500. const struct firmware *fw;
  501. u8 *fw_buffer;
  502. if (loadfirmware_handler == NULL && !(coredev->device_flags &
  503. SMS_DEVICE_FAMILY2))
  504. return -EINVAL;
  505. rc = request_firmware(&fw, filename, coredev->device);
  506. if (rc < 0) {
  507. sms_info("failed to open \"%s\"", filename);
  508. return rc;
  509. }
  510. sms_info("read FW %s, size=%zd", filename, fw->size);
  511. fw_buffer = kmalloc(ALIGN(fw->size, SMS_ALLOC_ALIGNMENT),
  512. GFP_KERNEL | GFP_DMA);
  513. if (fw_buffer) {
  514. memcpy(fw_buffer, fw->data, fw->size);
  515. rc = (coredev->device_flags & SMS_DEVICE_FAMILY2) ?
  516. smscore_load_firmware_family2(coredev,
  517. fw_buffer,
  518. fw->size) :
  519. loadfirmware_handler(coredev->context,
  520. fw_buffer, fw->size);
  521. kfree(fw_buffer);
  522. } else {
  523. sms_info("failed to allocate firmware buffer");
  524. rc = -ENOMEM;
  525. }
  526. release_firmware(fw);
  527. return rc;
  528. }
  529. /**
  530. * notifies all clients registered with the device, notifies hotplugs,
  531. * frees all buffers and coredev object
  532. *
  533. * @param coredev pointer to a coredev object returned by
  534. * smscore_register_device
  535. *
  536. * @return 0 on success, <0 on error.
  537. */
  538. void smscore_unregister_device(struct smscore_device_t *coredev)
  539. {
  540. struct smscore_buffer_t *cb;
  541. int num_buffers = 0;
  542. int retry = 0;
  543. kmutex_lock(&g_smscore_deviceslock);
  544. smscore_notify_clients(coredev);
  545. smscore_notify_callbacks(coredev, NULL, 0);
  546. /* at this point all buffers should be back
  547. * onresponse must no longer be called */
  548. while (1) {
  549. while ((cb = smscore_getbuffer(coredev))) {
  550. kfree(cb);
  551. num_buffers++;
  552. }
  553. if (num_buffers == coredev->num_buffers)
  554. break;
  555. if (++retry > 10) {
  556. sms_info("exiting although "
  557. "not all buffers released.");
  558. break;
  559. }
  560. sms_info("waiting for %d buffer(s)",
  561. coredev->num_buffers - num_buffers);
  562. msleep(100);
  563. }
  564. sms_info("freed %d buffers", num_buffers);
  565. if (coredev->common_buffer)
  566. dma_free_coherent(NULL, coredev->common_buffer_size,
  567. coredev->common_buffer,
  568. coredev->common_buffer_phys);
  569. list_del(&coredev->entry);
  570. kfree(coredev);
  571. kmutex_unlock(&g_smscore_deviceslock);
  572. sms_info("device %p destroyed", coredev);
  573. }
  574. EXPORT_SYMBOL_GPL(smscore_unregister_device);
  575. static int smscore_detect_mode(struct smscore_device_t *coredev)
  576. {
  577. void *buffer = kmalloc(sizeof(struct SmsMsgHdr_ST) + SMS_DMA_ALIGNMENT,
  578. GFP_KERNEL | GFP_DMA);
  579. struct SmsMsgHdr_ST *msg =
  580. (struct SmsMsgHdr_ST *) SMS_ALIGN_ADDRESS(buffer);
  581. int rc;
  582. if (!buffer)
  583. return -ENOMEM;
  584. SMS_INIT_MSG(msg, MSG_SMS_GET_VERSION_EX_REQ,
  585. sizeof(struct SmsMsgHdr_ST));
  586. rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength,
  587. &coredev->version_ex_done);
  588. if (rc == -ETIME) {
  589. sms_err("MSG_SMS_GET_VERSION_EX_REQ failed first try");
  590. if (wait_for_completion_timeout(&coredev->resume_done,
  591. msecs_to_jiffies(5000))) {
  592. rc = smscore_sendrequest_and_wait(
  593. coredev, msg, msg->msgLength,
  594. &coredev->version_ex_done);
  595. if (rc < 0)
  596. sms_err("MSG_SMS_GET_VERSION_EX_REQ failed "
  597. "second try, rc %d", rc);
  598. } else
  599. rc = -ETIME;
  600. }
  601. kfree(buffer);
  602. return rc;
  603. }
  604. static char *smscore_fw_lkup[][SMS_NUM_OF_DEVICE_TYPES] = {
  605. /*Stellar NOVA A0 Nova B0 VEGA*/
  606. /*DVBT*/
  607. {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"},
  608. /*DVBH*/
  609. {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"},
  610. /*TDMB*/
  611. {"none", "tdmb_nova_12mhz.inp", "tdmb_nova_12mhz_b0.inp", "none"},
  612. /*DABIP*/
  613. {"none", "none", "none", "none"},
  614. /*BDA*/
  615. {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"},
  616. /*ISDBT*/
  617. {"none", "isdbt_nova_12mhz.inp", "dvb_nova_12mhz.inp", "none"},
  618. /*ISDBTBDA*/
  619. {"none", "isdbt_nova_12mhz.inp", "isdbt_nova_12mhz_b0.inp", "none"},
  620. /*CMMB*/
  621. {"none", "none", "none", "cmmb_vega_12mhz.inp"}
  622. };
  623. static inline char *sms_get_fw_name(struct smscore_device_t *coredev,
  624. int mode, enum sms_device_type_st type)
  625. {
  626. char **fw = sms_get_board(smscore_get_board_id(coredev))->fw;
  627. return (fw && fw[mode]) ? fw[mode] : smscore_fw_lkup[mode][type];
  628. }
  629. /**
  630. * calls device handler to change mode of operation
  631. * NOTE: stellar/usb may disconnect when changing mode
  632. *
  633. * @param coredev pointer to a coredev object returned by
  634. * smscore_register_device
  635. * @param mode requested mode of operation
  636. *
  637. * @return 0 on success, <0 on error.
  638. */
  639. int smscore_set_device_mode(struct smscore_device_t *coredev, int mode)
  640. {
  641. void *buffer;
  642. int rc = 0;
  643. enum sms_device_type_st type;
  644. sms_debug("set device mode to %d", mode);
  645. if (coredev->device_flags & SMS_DEVICE_FAMILY2) {
  646. if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_RAW_TUNER) {
  647. sms_err("invalid mode specified %d", mode);
  648. return -EINVAL;
  649. }
  650. smscore_registry_setmode(coredev->devpath, mode);
  651. if (!(coredev->device_flags & SMS_DEVICE_NOT_READY)) {
  652. rc = smscore_detect_mode(coredev);
  653. if (rc < 0) {
  654. sms_err("mode detect failed %d", rc);
  655. return rc;
  656. }
  657. }
  658. if (coredev->mode == mode) {
  659. sms_info("device mode %d already set", mode);
  660. return 0;
  661. }
  662. if (!(coredev->modes_supported & (1 << mode))) {
  663. char *fw_filename;
  664. type = smscore_registry_gettype(coredev->devpath);
  665. fw_filename = sms_get_fw_name(coredev, mode, type);
  666. rc = smscore_load_firmware_from_file(coredev,
  667. fw_filename, NULL);
  668. if (rc < 0) {
  669. sms_warn("error %d loading firmware: %s, "
  670. "trying again with default firmware",
  671. rc, fw_filename);
  672. /* try again with the default firmware */
  673. fw_filename = smscore_fw_lkup[mode][type];
  674. rc = smscore_load_firmware_from_file(coredev,
  675. fw_filename, NULL);
  676. if (rc < 0) {
  677. sms_warn("error %d loading "
  678. "firmware: %s", rc,
  679. fw_filename);
  680. return rc;
  681. }
  682. }
  683. sms_log("firmware download success: %s", fw_filename);
  684. } else
  685. sms_info("mode %d supported by running "
  686. "firmware", mode);
  687. buffer = kmalloc(sizeof(struct SmsMsgData_ST) +
  688. SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA);
  689. if (buffer) {
  690. struct SmsMsgData_ST *msg =
  691. (struct SmsMsgData_ST *)
  692. SMS_ALIGN_ADDRESS(buffer);
  693. SMS_INIT_MSG(&msg->xMsgHeader, MSG_SMS_INIT_DEVICE_REQ,
  694. sizeof(struct SmsMsgData_ST));
  695. msg->msgData[0] = mode;
  696. rc = smscore_sendrequest_and_wait(
  697. coredev, msg, msg->xMsgHeader.msgLength,
  698. &coredev->init_device_done);
  699. kfree(buffer);
  700. } else {
  701. sms_err("Could not allocate buffer for "
  702. "init device message.");
  703. rc = -ENOMEM;
  704. }
  705. } else {
  706. if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) {
  707. sms_err("invalid mode specified %d", mode);
  708. return -EINVAL;
  709. }
  710. smscore_registry_setmode(coredev->devpath, mode);
  711. if (coredev->detectmode_handler)
  712. coredev->detectmode_handler(coredev->context,
  713. &coredev->mode);
  714. if (coredev->mode != mode && coredev->setmode_handler)
  715. rc = coredev->setmode_handler(coredev->context, mode);
  716. }
  717. if (rc >= 0) {
  718. coredev->mode = mode;
  719. coredev->device_flags &= ~SMS_DEVICE_NOT_READY;
  720. }
  721. if (rc != 0)
  722. sms_err("return error code %d.", rc);
  723. return rc;
  724. }
  725. /**
  726. * calls device handler to get current mode of operation
  727. *
  728. * @param coredev pointer to a coredev object returned by
  729. * smscore_register_device
  730. *
  731. * @return current mode
  732. */
  733. int smscore_get_device_mode(struct smscore_device_t *coredev)
  734. {
  735. return coredev->mode;
  736. }
  737. EXPORT_SYMBOL_GPL(smscore_get_device_mode);
  738. /**
  739. * find client by response id & type within the clients list.
  740. * return client handle or NULL.
  741. *
  742. * @param coredev pointer to a coredev object returned by
  743. * smscore_register_device
  744. * @param data_type client data type (SMS_DONT_CARE for all types)
  745. * @param id client id (SMS_DONT_CARE for all id)
  746. *
  747. */
  748. static struct
  749. smscore_client_t *smscore_find_client(struct smscore_device_t *coredev,
  750. int data_type, int id)
  751. {
  752. struct smscore_client_t *client = NULL;
  753. struct list_head *next, *first;
  754. unsigned long flags;
  755. struct list_head *firstid, *nextid;
  756. spin_lock_irqsave(&coredev->clientslock, flags);
  757. first = &coredev->clients;
  758. for (next = first->next;
  759. (next != first) && !client;
  760. next = next->next) {
  761. firstid = &((struct smscore_client_t *)next)->idlist;
  762. for (nextid = firstid->next;
  763. nextid != firstid;
  764. nextid = nextid->next) {
  765. if ((((struct smscore_idlist_t *)nextid)->id == id) &&
  766. (((struct smscore_idlist_t *)nextid)->data_type == data_type ||
  767. (((struct smscore_idlist_t *)nextid)->data_type == 0))) {
  768. client = (struct smscore_client_t *) next;
  769. break;
  770. }
  771. }
  772. }
  773. spin_unlock_irqrestore(&coredev->clientslock, flags);
  774. return client;
  775. }
  776. /**
  777. * find client by response id/type, call clients onresponse handler
  778. * return buffer to pool on error
  779. *
  780. * @param coredev pointer to a coredev object returned by
  781. * smscore_register_device
  782. * @param cb pointer to response buffer descriptor
  783. *
  784. */
  785. void smscore_onresponse(struct smscore_device_t *coredev,
  786. struct smscore_buffer_t *cb)
  787. {
  788. struct SmsMsgHdr_ST *phdr =
  789. (struct SmsMsgHdr_ST *)((u8 *) cb->p + cb->offset);
  790. struct smscore_client_t *client =
  791. smscore_find_client(coredev, phdr->msgType, phdr->msgDstId);
  792. int rc = -EBUSY;
  793. static unsigned long last_sample_time; /* = 0; */
  794. static int data_total; /* = 0; */
  795. unsigned long time_now = jiffies_to_msecs(jiffies);
  796. if (!last_sample_time)
  797. last_sample_time = time_now;
  798. if (time_now - last_sample_time > 10000) {
  799. sms_debug("\ndata rate %d bytes/secs",
  800. (int)((data_total * 1000) /
  801. (time_now - last_sample_time)));
  802. last_sample_time = time_now;
  803. data_total = 0;
  804. }
  805. data_total += cb->size;
  806. /* If no client registered for type & id,
  807. * check for control client where type is not registered */
  808. if (client)
  809. rc = client->onresponse_handler(client->context, cb);
  810. if (rc < 0) {
  811. switch (phdr->msgType) {
  812. case MSG_SMS_GET_VERSION_EX_RES:
  813. {
  814. struct SmsVersionRes_ST *ver =
  815. (struct SmsVersionRes_ST *) phdr;
  816. sms_debug("MSG_SMS_GET_VERSION_EX_RES "
  817. "id %d prots 0x%x ver %d.%d",
  818. ver->FirmwareId, ver->SupportedProtocols,
  819. ver->RomVersionMajor, ver->RomVersionMinor);
  820. coredev->mode = ver->FirmwareId == 255 ?
  821. DEVICE_MODE_NONE : ver->FirmwareId;
  822. coredev->modes_supported = ver->SupportedProtocols;
  823. complete(&coredev->version_ex_done);
  824. break;
  825. }
  826. case MSG_SMS_INIT_DEVICE_RES:
  827. sms_debug("MSG_SMS_INIT_DEVICE_RES");
  828. complete(&coredev->init_device_done);
  829. break;
  830. case MSG_SW_RELOAD_START_RES:
  831. sms_debug("MSG_SW_RELOAD_START_RES");
  832. complete(&coredev->reload_start_done);
  833. break;
  834. case MSG_SMS_DATA_DOWNLOAD_RES:
  835. complete(&coredev->data_download_done);
  836. break;
  837. case MSG_SW_RELOAD_EXEC_RES:
  838. sms_debug("MSG_SW_RELOAD_EXEC_RES");
  839. break;
  840. case MSG_SMS_SWDOWNLOAD_TRIGGER_RES:
  841. sms_debug("MSG_SMS_SWDOWNLOAD_TRIGGER_RES");
  842. complete(&coredev->trigger_done);
  843. break;
  844. case MSG_SMS_SLEEP_RESUME_COMP_IND:
  845. complete(&coredev->resume_done);
  846. break;
  847. default:
  848. break;
  849. }
  850. smscore_putbuffer(coredev, cb);
  851. }
  852. }
  853. EXPORT_SYMBOL_GPL(smscore_onresponse);
  854. /**
  855. * return pointer to next free buffer descriptor from core pool
  856. *
  857. * @param coredev pointer to a coredev object returned by
  858. * smscore_register_device
  859. *
  860. * @return pointer to descriptor on success, NULL on error.
  861. */
  862. struct smscore_buffer_t *smscore_getbuffer(struct smscore_device_t *coredev)
  863. {
  864. struct smscore_buffer_t *cb = NULL;
  865. unsigned long flags;
  866. spin_lock_irqsave(&coredev->bufferslock, flags);
  867. if (!list_empty(&coredev->buffers)) {
  868. cb = (struct smscore_buffer_t *) coredev->buffers.next;
  869. list_del(&cb->entry);
  870. }
  871. spin_unlock_irqrestore(&coredev->bufferslock, flags);
  872. return cb;
  873. }
  874. EXPORT_SYMBOL_GPL(smscore_getbuffer);
  875. /**
  876. * return buffer descriptor to a pool
  877. *
  878. * @param coredev pointer to a coredev object returned by
  879. * smscore_register_device
  880. * @param cb pointer buffer descriptor
  881. *
  882. */
  883. void smscore_putbuffer(struct smscore_device_t *coredev,
  884. struct smscore_buffer_t *cb)
  885. {
  886. list_add_locked(&cb->entry, &coredev->buffers, &coredev->bufferslock);
  887. }
  888. EXPORT_SYMBOL_GPL(smscore_putbuffer);
  889. static int smscore_validate_client(struct smscore_device_t *coredev,
  890. struct smscore_client_t *client,
  891. int data_type, int id)
  892. {
  893. struct smscore_idlist_t *listentry;
  894. struct smscore_client_t *registered_client;
  895. if (!client) {
  896. sms_err("bad parameter.");
  897. return -EFAULT;
  898. }
  899. registered_client = smscore_find_client(coredev, data_type, id);
  900. if (registered_client == client)
  901. return 0;
  902. if (registered_client) {
  903. sms_err("The msg ID already registered to another client.");
  904. return -EEXIST;
  905. }
  906. listentry = kzalloc(sizeof(struct smscore_idlist_t), GFP_KERNEL);
  907. if (!listentry) {
  908. sms_err("Can't allocate memory for client id.");
  909. return -ENOMEM;
  910. }
  911. listentry->id = id;
  912. listentry->data_type = data_type;
  913. list_add_locked(&listentry->entry, &client->idlist,
  914. &coredev->clientslock);
  915. return 0;
  916. }
  917. /**
  918. * creates smsclient object, check that id is taken by another client
  919. *
  920. * @param coredev pointer to a coredev object from clients hotplug
  921. * @param initial_id all messages with this id would be sent to this client
  922. * @param data_type all messages of this type would be sent to this client
  923. * @param onresponse_handler client handler that is called to
  924. * process incoming messages
  925. * @param onremove_handler client handler that is called when device is removed
  926. * @param context client-specific context
  927. * @param client pointer to a value that receives created smsclient object
  928. *
  929. * @return 0 on success, <0 on error.
  930. */
  931. int smscore_register_client(struct smscore_device_t *coredev,
  932. struct smsclient_params_t *params,
  933. struct smscore_client_t **client)
  934. {
  935. struct smscore_client_t *newclient;
  936. /* check that no other channel with same parameters exists */
  937. if (smscore_find_client(coredev, params->data_type,
  938. params->initial_id)) {
  939. sms_err("Client already exist.");
  940. return -EEXIST;
  941. }
  942. newclient = kzalloc(sizeof(struct smscore_client_t), GFP_KERNEL);
  943. if (!newclient) {
  944. sms_err("Failed to allocate memory for client.");
  945. return -ENOMEM;
  946. }
  947. INIT_LIST_HEAD(&newclient->idlist);
  948. newclient->coredev = coredev;
  949. newclient->onresponse_handler = params->onresponse_handler;
  950. newclient->onremove_handler = params->onremove_handler;
  951. newclient->context = params->context;
  952. list_add_locked(&newclient->entry, &coredev->clients,
  953. &coredev->clientslock);
  954. smscore_validate_client(coredev, newclient, params->data_type,
  955. params->initial_id);
  956. *client = newclient;
  957. sms_debug("%p %d %d", params->context, params->data_type,
  958. params->initial_id);
  959. return 0;
  960. }
  961. EXPORT_SYMBOL_GPL(smscore_register_client);
  962. /**
  963. * frees smsclient object and all subclients associated with it
  964. *
  965. * @param client pointer to smsclient object returned by
  966. * smscore_register_client
  967. *
  968. */
  969. void smscore_unregister_client(struct smscore_client_t *client)
  970. {
  971. struct smscore_device_t *coredev = client->coredev;
  972. unsigned long flags;
  973. spin_lock_irqsave(&coredev->clientslock, flags);
  974. while (!list_empty(&client->idlist)) {
  975. struct smscore_idlist_t *identry =
  976. (struct smscore_idlist_t *) client->idlist.next;
  977. list_del(&identry->entry);
  978. kfree(identry);
  979. }
  980. sms_info("%p", client->context);
  981. list_del(&client->entry);
  982. kfree(client);
  983. spin_unlock_irqrestore(&coredev->clientslock, flags);
  984. }
  985. EXPORT_SYMBOL_GPL(smscore_unregister_client);
  986. /**
  987. * verifies that source id is not taken by another client,
  988. * calls device handler to send requests to the device
  989. *
  990. * @param client pointer to smsclient object returned by
  991. * smscore_register_client
  992. * @param buffer pointer to a request buffer
  993. * @param size size (in bytes) of request buffer
  994. *
  995. * @return 0 on success, <0 on error.
  996. */
  997. int smsclient_sendrequest(struct smscore_client_t *client,
  998. void *buffer, size_t size)
  999. {
  1000. struct smscore_device_t *coredev;
  1001. struct SmsMsgHdr_ST *phdr = (struct SmsMsgHdr_ST *) buffer;
  1002. int rc;
  1003. if (client == NULL) {
  1004. sms_err("Got NULL client");
  1005. return -EINVAL;
  1006. }
  1007. coredev = client->coredev;
  1008. /* check that no other channel with same id exists */
  1009. if (coredev == NULL) {
  1010. sms_err("Got NULL coredev");
  1011. return -EINVAL;
  1012. }
  1013. rc = smscore_validate_client(client->coredev, client, 0,
  1014. phdr->msgSrcId);
  1015. if (rc < 0)
  1016. return rc;
  1017. return coredev->sendrequest_handler(coredev->context, buffer, size);
  1018. }
  1019. EXPORT_SYMBOL_GPL(smsclient_sendrequest);
  1020. int smscore_configure_gpio(struct smscore_device_t *coredev, u32 pin,
  1021. struct smscore_gpio_config *pinconfig)
  1022. {
  1023. struct {
  1024. struct SmsMsgHdr_ST hdr;
  1025. u32 data[6];
  1026. } msg;
  1027. if (coredev->device_flags & SMS_DEVICE_FAMILY2) {
  1028. msg.hdr.msgSrcId = DVBT_BDA_CONTROL_MSG_ID;
  1029. msg.hdr.msgDstId = HIF_TASK;
  1030. msg.hdr.msgFlags = 0;
  1031. msg.hdr.msgType = MSG_SMS_GPIO_CONFIG_EX_REQ;
  1032. msg.hdr.msgLength = sizeof(msg);
  1033. msg.data[0] = pin;
  1034. msg.data[1] = pinconfig->pullupdown;
  1035. /* Convert slew rate for Nova: Fast(0) = 3 / Slow(1) = 0; */
  1036. msg.data[2] = pinconfig->outputslewrate == 0 ? 3 : 0;
  1037. switch (pinconfig->outputdriving) {
  1038. case SMS_GPIO_OUTPUTDRIVING_16mA:
  1039. msg.data[3] = 7; /* Nova - 16mA */
  1040. break;
  1041. case SMS_GPIO_OUTPUTDRIVING_12mA:
  1042. msg.data[3] = 5; /* Nova - 11mA */
  1043. break;
  1044. case SMS_GPIO_OUTPUTDRIVING_8mA:
  1045. msg.data[3] = 3; /* Nova - 7mA */
  1046. break;
  1047. case SMS_GPIO_OUTPUTDRIVING_4mA:
  1048. default:
  1049. msg.data[3] = 2; /* Nova - 4mA */
  1050. break;
  1051. }
  1052. msg.data[4] = pinconfig->direction;
  1053. msg.data[5] = 0;
  1054. } else /* TODO: SMS_DEVICE_FAMILY1 */
  1055. return -EINVAL;
  1056. return coredev->sendrequest_handler(coredev->context,
  1057. &msg, sizeof(msg));
  1058. }
  1059. int smscore_set_gpio(struct smscore_device_t *coredev, u32 pin, int level)
  1060. {
  1061. struct {
  1062. struct SmsMsgHdr_ST hdr;
  1063. u32 data[3];
  1064. } msg;
  1065. if (pin > MAX_GPIO_PIN_NUMBER)
  1066. return -EINVAL;
  1067. msg.hdr.msgSrcId = DVBT_BDA_CONTROL_MSG_ID;
  1068. msg.hdr.msgDstId = HIF_TASK;
  1069. msg.hdr.msgFlags = 0;
  1070. msg.hdr.msgType = MSG_SMS_GPIO_SET_LEVEL_REQ;
  1071. msg.hdr.msgLength = sizeof(msg);
  1072. msg.data[0] = pin;
  1073. msg.data[1] = level ? 1 : 0;
  1074. msg.data[2] = 0;
  1075. return coredev->sendrequest_handler(coredev->context,
  1076. &msg, sizeof(msg));
  1077. }
  1078. static int __init smscore_module_init(void)
  1079. {
  1080. int rc = 0;
  1081. INIT_LIST_HEAD(&g_smscore_notifyees);
  1082. INIT_LIST_HEAD(&g_smscore_devices);
  1083. kmutex_init(&g_smscore_deviceslock);
  1084. INIT_LIST_HEAD(&g_smscore_registry);
  1085. kmutex_init(&g_smscore_registrylock);
  1086. return rc;
  1087. sms_debug("rc %d", rc);
  1088. return rc;
  1089. }
  1090. static void __exit smscore_module_exit(void)
  1091. {
  1092. kmutex_lock(&g_smscore_deviceslock);
  1093. while (!list_empty(&g_smscore_notifyees)) {
  1094. struct smscore_device_notifyee_t *notifyee =
  1095. (struct smscore_device_notifyee_t *)
  1096. g_smscore_notifyees.next;
  1097. list_del(&notifyee->entry);
  1098. kfree(notifyee);
  1099. }
  1100. kmutex_unlock(&g_smscore_deviceslock);
  1101. kmutex_lock(&g_smscore_registrylock);
  1102. while (!list_empty(&g_smscore_registry)) {
  1103. struct smscore_registry_entry_t *entry =
  1104. (struct smscore_registry_entry_t *)
  1105. g_smscore_registry.next;
  1106. list_del(&entry->entry);
  1107. kfree(entry);
  1108. }
  1109. kmutex_unlock(&g_smscore_registrylock);
  1110. sms_debug("");
  1111. }
  1112. module_init(smscore_module_init);
  1113. module_exit(smscore_module_exit);
  1114. MODULE_DESCRIPTION("Siano MDTV Core module");
  1115. MODULE_AUTHOR("Siano Mobile Silicon, Inc. (uris@siano-ms.com)");
  1116. MODULE_LICENSE("GPL");