git.oblomov.eu Git - linux-2.6/blob - drivers/media/dvb/siano/smscoreapi.c

   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
  24 #include <linux/kernel.h>
  25 #include <linux/init.h>
  26 #include <linux/module.h>
  27 #include <linux/moduleparam.h>
  28 #include <linux/dma-mapping.h>
  29 #include <linux/delay.h>
  30 #include <linux/io.h>
  31
  32 #include <linux/firmware.h>
  33 #include <linux/wait.h>
  34 #include <asm/byteorder.h>
  35
  36 #include "smscoreapi.h"
  37 #include "sms-cards.h"
  38 #include "smsir.h"
  39 #include "smsendian.h"
  40
  41 static int sms_dbg;
  42 module_param_named(debug, sms_dbg, int, 0644);
  43 MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))");
  44
  45 struct smscore_device_notifyee_t {
  46         struct list_head entry;
  47         hotplug_t hotplug;
  48 };
  49
  50 struct smscore_idlist_t {
  51         struct list_head entry;
  52         int             id;
  53         int             data_type;
  54 };
  55
  56 struct smscore_client_t {
  57         struct list_head entry;
  58         struct smscore_device_t *coredev;
  59         void                    *context;
  60         struct list_head        idlist;
  61         onresponse_t    onresponse_handler;
  62         onremove_t              onremove_handler;
  63 };
  64
  65 void smscore_set_board_id(struct smscore_device_t *core, int id)
  66 {
  67         core->board_id = id;
  68 }
  69
  70 int smscore_led_state(struct smscore_device_t *core, int led)
  71 {
  72         if (led >= 0)
  73                 core->led_state = led;
  74         return core->led_state;
  75 }
  76 EXPORT_SYMBOL_GPL(smscore_set_board_id);
  77
  78 int smscore_get_board_id(struct smscore_device_t *core)
  79 {
  80         return core->board_id;
  81 }
  82 EXPORT_SYMBOL_GPL(smscore_get_board_id);
  83
  84 struct smscore_registry_entry_t {
  85         struct list_head entry;
  86         char                    devpath[32];
  87         int                             mode;
  88         enum sms_device_type_st type;
  89 };
  90
  91 static struct list_head g_smscore_notifyees;
  92 static struct list_head g_smscore_devices;
  93 static struct mutex g_smscore_deviceslock;
  94
  95 static struct list_head g_smscore_registry;
  96 static struct mutex g_smscore_registrylock;
  97
  98 static int default_mode = 4;
  99
 100 module_param(default_mode, int, 0644);
 101 MODULE_PARM_DESC(default_mode, "default firmware id (device mode)");
 102
 103 static struct smscore_registry_entry_t *smscore_find_registry(char *devpath)
 104 {
 105         struct smscore_registry_entry_t *entry;
 106         struct list_head *next;
 107
 108         kmutex_lock(&g_smscore_registrylock);
 109         for (next = g_smscore_registry.next;
 110              next != &g_smscore_registry;
 111              next = next->next) {
 112                 entry = (struct smscore_registry_entry_t *) next;
 113                 if (!strcmp(entry->devpath, devpath)) {
 114                         kmutex_unlock(&g_smscore_registrylock);
 115                         return entry;
 116                 }
 117         }
 118         entry = (struct smscore_registry_entry_t *)
 119                         kmalloc(sizeof(struct smscore_registry_entry_t),
 120                                 GFP_KERNEL);
 121         if (entry) {
 122                 entry->mode = default_mode;
 123                 strcpy(entry->devpath, devpath);
 124                 list_add(&entry->entry, &g_smscore_registry);
 125         } else
 126                 sms_err("failed to create smscore_registry.");
 127         kmutex_unlock(&g_smscore_registrylock);
 128         return entry;
 129 }
 130
 131 int smscore_registry_getmode(char *devpath)
 132 {
 133         struct smscore_registry_entry_t *entry;
 134
 135         entry = smscore_find_registry(devpath);
 136         if (entry)
 137                 return entry->mode;
 138         else
 139                 sms_err("No registry found.");
 140
 141         return default_mode;
 142 }
 143 EXPORT_SYMBOL_GPL(smscore_registry_getmode);
 144
 145 static enum sms_device_type_st smscore_registry_gettype(char *devpath)
 146 {
 147         struct smscore_registry_entry_t *entry;
 148
 149         entry = smscore_find_registry(devpath);
 150         if (entry)
 151                 return entry->type;
 152         else
 153                 sms_err("No registry found.");
 154
 155         return -1;
 156 }
 157
 158 void smscore_registry_setmode(char *devpath, int mode)
 159 {
 160         struct smscore_registry_entry_t *entry;
 161
 162         entry = smscore_find_registry(devpath);
 163         if (entry)
 164                 entry->mode = mode;
 165         else
 166                 sms_err("No registry found.");
 167 }
 168
 169 static void smscore_registry_settype(char *devpath,
 170                                      enum sms_device_type_st type)
 171 {
 172         struct smscore_registry_entry_t *entry;
 173
 174         entry = smscore_find_registry(devpath);
 175         if (entry)
 176                 entry->type = type;
 177         else
 178                 sms_err("No registry found.");
 179 }
 180
 181
 182 static void list_add_locked(struct list_head *new, struct list_head *head,
 183                             spinlock_t *lock)
 184 {
 185         unsigned long flags;
 186
 187         spin_lock_irqsave(lock, flags);
 188
 189         list_add(new, head);
 190
 191         spin_unlock_irqrestore(lock, flags);
 192 }
 193
 194 /**
 195  * register a client callback that called when device plugged in/unplugged
 196  * NOTE: if devices exist callback is called immediately for each device
 197  *
 198  * @param hotplug callback
 199  *
 200  * @return 0 on success, <0 on error.
 201  */
 202 int smscore_register_hotplug(hotplug_t hotplug)
 203 {
 204         struct smscore_device_notifyee_t *notifyee;
 205         struct list_head *next, *first;
 206         int rc = 0;
 207
 208         kmutex_lock(&g_smscore_deviceslock);
 209
 210         notifyee = kmalloc(sizeof(struct smscore_device_notifyee_t),
 211                            GFP_KERNEL);
 212         if (notifyee) {
 213                 /* now notify callback about existing devices */
 214                 first = &g_smscore_devices;
 215                 for (next = first->next;
 216                      next != first && !rc;
 217                      next = next->next) {
 218                         struct smscore_device_t *coredev =
 219                                 (struct smscore_device_t *) next;
 220                         rc = hotplug(coredev, coredev->device, 1);
 221                 }
 222
 223                 if (rc >= 0) {
 224                         notifyee->hotplug = hotplug;
 225                         list_add(&notifyee->entry, &g_smscore_notifyees);
 226                 } else
 227                         kfree(notifyee);
 228         } else
 229                 rc = -ENOMEM;
 230
 231         kmutex_unlock(&g_smscore_deviceslock);
 232
 233         return rc;
 234 }
 235 EXPORT_SYMBOL_GPL(smscore_register_hotplug);
 236
 237 /**
 238  * unregister a client callback that called when device plugged in/unplugged
 239  *
 240  * @param hotplug callback
 241  *
 242  */
 243 void smscore_unregister_hotplug(hotplug_t hotplug)
 244 {
 245         struct list_head *next, *first;
 246
 247         kmutex_lock(&g_smscore_deviceslock);
 248
 249         first = &g_smscore_notifyees;
 250
 251         for (next = first->next; next != first;) {
 252                 struct smscore_device_notifyee_t *notifyee =
 253                         (struct smscore_device_notifyee_t *) next;
 254                 next = next->next;
 255
 256                 if (notifyee->hotplug == hotplug) {
 257                         list_del(&notifyee->entry);
 258                         kfree(notifyee);
 259                 }
 260         }
 261
 262         kmutex_unlock(&g_smscore_deviceslock);
 263 }
 264 EXPORT_SYMBOL_GPL(smscore_unregister_hotplug);
 265
 266 static void smscore_notify_clients(struct smscore_device_t *coredev)
 267 {
 268         struct smscore_client_t *client;
 269
 270         /* the client must call smscore_unregister_client from remove handler */
 271         while (!list_empty(&coredev->clients)) {
 272                 client = (struct smscore_client_t *) coredev->clients.next;
 273                 client->onremove_handler(client->context);
 274         }
 275 }
 276
 277 static int smscore_notify_callbacks(struct smscore_device_t *coredev,
 278                                     struct device *device, int arrival)
 279 {
 280         struct list_head *next, *first;
 281         int rc = 0;
 282
 283         /* note: must be called under g_deviceslock */
 284
 285         first = &g_smscore_notifyees;
 286
 287         for (next = first->next; next != first; next = next->next) {
 288                 rc = ((struct smscore_device_notifyee_t *) next)->
 289                                 hotplug(coredev, device, arrival);
 290                 if (rc < 0)
 291                         break;
 292         }
 293
 294         return rc;
 295 }
 296
 297 static struct
 298 smscore_buffer_t *smscore_createbuffer(u8 *buffer, void *common_buffer,
 299                                        dma_addr_t common_buffer_phys)
 300 {
 301         struct smscore_buffer_t *cb =
 302                 kmalloc(sizeof(struct smscore_buffer_t), GFP_KERNEL);
 303         if (!cb) {
 304                 sms_info("kmalloc(...) failed");
 305                 return NULL;
 306         }
 307
 308         cb->p = buffer;
 309         cb->offset_in_common = buffer - (u8 *) common_buffer;
 310         cb->phys = common_buffer_phys + cb->offset_in_common;
 311
 312         return cb;
 313 }
 314
 315 /**
 316  * creates coredev object for a device, prepares buffers,
 317  * creates buffer mappings, notifies registered hotplugs about new device.
 318  *
 319  * @param params device pointer to struct with device specific parameters
 320  *               and handlers
 321  * @param coredev pointer to a value that receives created coredev object
 322  *
 323  * @return 0 on success, <0 on error.
 324  */
 325 int smscore_register_device(struct smsdevice_params_t *params,
 326                             struct smscore_device_t **coredev)
 327 {
 328         struct smscore_device_t *dev;
 329         u8 *buffer;
 330
 331         dev = kzalloc(sizeof(struct smscore_device_t), GFP_KERNEL);
 332         if (!dev) {
 333                 sms_info("kzalloc(...) failed");
 334                 return -ENOMEM;
 335         }
 336
 337         /* init list entry so it could be safe in smscore_unregister_device */
 338         INIT_LIST_HEAD(&dev->entry);
 339
 340         /* init queues */
 341         INIT_LIST_HEAD(&dev->clients);
 342         INIT_LIST_HEAD(&dev->buffers);
 343
 344         /* init locks */
 345         spin_lock_init(&dev->clientslock);
 346         spin_lock_init(&dev->bufferslock);
 347
 348         /* init completion events */
 349         init_completion(&dev->version_ex_done);
 350         init_completion(&dev->data_download_done);
 351         init_completion(&dev->trigger_done);
 352         init_completion(&dev->init_device_done);
 353         init_completion(&dev->reload_start_done);
 354         init_completion(&dev->resume_done);
 355         init_completion(&dev->ir_init_done);
 356
 357         /* Buffer management */
 358         init_waitqueue_head(&dev->buffer_mng_waitq);
 359
 360         /* alloc common buffer */
 361         dev->common_buffer_size = params->buffer_size * params->num_buffers;
 362         dev->common_buffer = dma_alloc_coherent(NULL, dev->common_buffer_size,
 363                                                 &dev->common_buffer_phys,
 364                                                 GFP_KERNEL | GFP_DMA);
 365         if (!dev->common_buffer) {
 366                 smscore_unregister_device(dev);
 367                 return -ENOMEM;
 368         }
 369
 370         /* prepare dma buffers */
 371         for (buffer = dev->common_buffer;
 372              dev->num_buffers < params->num_buffers;
 373              dev->num_buffers++, buffer += params->buffer_size) {
 374                 struct smscore_buffer_t *cb =
 375                         smscore_createbuffer(buffer, dev->common_buffer,
 376                                              dev->common_buffer_phys);
 377                 if (!cb) {
 378                         smscore_unregister_device(dev);
 379                         return -ENOMEM;
 380                 }
 381
 382                 smscore_putbuffer(dev, cb);
 383         }
 384
 385         sms_info("allocated %d buffers", dev->num_buffers);
 386
 387         dev->mode = DEVICE_MODE_NONE;
 388         dev->context = params->context;
 389         dev->device = params->device;
 390         dev->setmode_handler = params->setmode_handler;
 391         dev->detectmode_handler = params->detectmode_handler;
 392         dev->sendrequest_handler = params->sendrequest_handler;
 393         dev->preload_handler = params->preload_handler;
 394         dev->postload_handler = params->postload_handler;
 395
 396         dev->device_flags = params->flags;
 397         strcpy(dev->devpath, params->devpath);
 398
 399         smscore_registry_settype(dev->devpath, params->device_type);
 400
 401         /* add device to devices list */
 402         kmutex_lock(&g_smscore_deviceslock);
 403         list_add(&dev->entry, &g_smscore_devices);
 404         kmutex_unlock(&g_smscore_deviceslock);
 405
 406         *coredev = dev;
 407
 408         sms_info("device %p created", dev);
 409
 410         return 0;
 411 }
 412 EXPORT_SYMBOL_GPL(smscore_register_device);
 413
 414
 415 static int smscore_sendrequest_and_wait(struct smscore_device_t *coredev,
 416                 void *buffer, size_t size, struct completion *completion) {
 417         int rc = coredev->sendrequest_handler(coredev->context, buffer, size);
 418         if (rc < 0) {
 419                 sms_info("sendrequest returned error %d", rc);
 420                 return rc;
 421         }
 422
 423         return wait_for_completion_timeout(completion,
 424                         msecs_to_jiffies(SMS_PROTOCOL_MAX_RAOUNDTRIP_MS)) ?
 425                         0 : -ETIME;
 426 }
 427
 428 /**
 429  * Starts & enables IR operations
 430  *
 431  * @return 0 on success, < 0 on error.
 432  */
 433 static int smscore_init_ir(struct smscore_device_t *coredev)
 434 {
 435         int ir_io;
 436         int rc;
 437         void *buffer;
 438
 439         coredev->ir.input_dev = NULL;
 440         ir_io = sms_get_board(smscore_get_board_id(coredev))->board_cfg.ir;
 441         if (ir_io) {/* only if IR port exist we use IR sub-module */
 442                 sms_info("IR loading");
 443                 rc = sms_ir_init(coredev);
 444
 445                 if      (rc != 0)
 446                         sms_err("Error initialization DTV IR sub-module");
 447                 else {
 448                         buffer = kmalloc(sizeof(struct SmsMsgData_ST2) +
 449                                                 SMS_DMA_ALIGNMENT,
 450                                                 GFP_KERNEL | GFP_DMA);
 451                         if (buffer) {
 452                                 struct SmsMsgData_ST2 *msg =
 453                                 (struct SmsMsgData_ST2 *)
 454                                 SMS_ALIGN_ADDRESS(buffer);
 455
 456                                 SMS_INIT_MSG(&msg->xMsgHeader,
 457                                                 MSG_SMS_START_IR_REQ,
 458                                                 sizeof(struct SmsMsgData_ST2));
 459                                 msg->msgData[0] = coredev->ir.controller;
 460                                 msg->msgData[1] = coredev->ir.timeout;
 461
 462                                 smsendian_handle_tx_message(
 463                                         (struct SmsMsgHdr_ST2 *)msg);
 464                                 rc = smscore_sendrequest_and_wait(coredev, msg,
 465                                                 msg->xMsgHeader. msgLength,
 466                                                 &coredev->ir_init_done);
 467
 468                                 kfree(buffer);
 469                         } else
 470                                 sms_err
 471                                 ("Sending IR initialization message failed");
 472                 }
 473         } else
 474                 sms_info("IR port has not been detected");
 475
 476         return 0;
 477 }
 478
 479 /**
 480  * sets initial device mode and notifies client hotplugs that device is ready
 481  *
 482  * @param coredev pointer to a coredev object returned by
 483  *                smscore_register_device
 484  *
 485  * @return 0 on success, <0 on error.
 486  */
 487 int smscore_start_device(struct smscore_device_t *coredev)
 488 {
 489         int rc = smscore_set_device_mode(
 490                         coredev, smscore_registry_getmode(coredev->devpath));
 491         if (rc < 0) {
 492                 sms_info("set device mode faile , rc %d", rc);
 493                 return rc;
 494         }
 495
 496         kmutex_lock(&g_smscore_deviceslock);
 497
 498         rc = smscore_notify_callbacks(coredev, coredev->device, 1);
 499         smscore_init_ir(coredev);
 500
 501         sms_info("device %p started, rc %d", coredev, rc);
 502
 503         kmutex_unlock(&g_smscore_deviceslock);
 504
 505         return rc;
 506 }
 507 EXPORT_SYMBOL_GPL(smscore_start_device);
 508
 509
 510 static int smscore_load_firmware_family2(struct smscore_device_t *coredev,
 511                                          void *buffer, size_t size)
 512 {
 513         struct SmsFirmware_ST *firmware = (struct SmsFirmware_ST *) buffer;
 514         struct SmsMsgHdr_ST *msg;
 515         u32 mem_address;
 516         u8 *payload = firmware->Payload;
 517         int rc = 0;
 518         firmware->StartAddress = le32_to_cpu(firmware->StartAddress);
 519         firmware->Length = le32_to_cpu(firmware->Length);
 520
 521         mem_address = firmware->StartAddress;
 522
 523         sms_info("loading FW to addr 0x%x size %d",
 524                  mem_address, firmware->Length);
 525         if (coredev->preload_handler) {
 526                 rc = coredev->preload_handler(coredev->context);
 527                 if (rc < 0)
 528                         return rc;
 529         }
 530
 531         /* PAGE_SIZE buffer shall be enough and dma aligned */
 532         msg = kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA);
 533         if (!msg)
 534                 return -ENOMEM;
 535
 536         if (coredev->mode != DEVICE_MODE_NONE) {
 537                 sms_debug("sending reload command.");
 538                 SMS_INIT_MSG(msg, MSG_SW_RELOAD_START_REQ,
 539                              sizeof(struct SmsMsgHdr_ST));
 540                 rc = smscore_sendrequest_and_wait(coredev, msg,
 541                                                   msg->msgLength,
 542                                                   &coredev->reload_start_done);
 543                 mem_address = *(u32 *) &payload[20];
 544         }
 545
 546         while (size && rc >= 0) {
 547                 struct SmsDataDownload_ST *DataMsg =
 548                         (struct SmsDataDownload_ST *) msg;
 549                 int payload_size = min((int) size, SMS_MAX_PAYLOAD_SIZE);
 550
 551                 SMS_INIT_MSG(msg, MSG_SMS_DATA_DOWNLOAD_REQ,
 552                              (u16)(sizeof(struct SmsMsgHdr_ST) +
 553                                       sizeof(u32) + payload_size));
 554
 555                 DataMsg->MemAddr = mem_address;
 556                 memcpy(DataMsg->Payload, payload, payload_size);
 557
 558                 if ((coredev->device_flags & SMS_ROM_NO_RESPONSE) &&
 559                     (coredev->mode == DEVICE_MODE_NONE))
 560                         rc = coredev->sendrequest_handler(
 561                                 coredev->context, DataMsg,
 562                                 DataMsg->xMsgHeader.msgLength);
 563                 else
 564                         rc = smscore_sendrequest_and_wait(
 565                                 coredev, DataMsg,
 566                                 DataMsg->xMsgHeader.msgLength,
 567                                 &coredev->data_download_done);
 568
 569                 payload += payload_size;
 570                 size -= payload_size;
 571                 mem_address += payload_size;
 572         }
 573
 574         if (rc >= 0) {
 575                 if (coredev->mode == DEVICE_MODE_NONE) {
 576                         struct SmsMsgData_ST *TriggerMsg =
 577                                 (struct SmsMsgData_ST *) msg;
 578
 579                         SMS_INIT_MSG(msg, MSG_SMS_SWDOWNLOAD_TRIGGER_REQ,
 580                                      sizeof(struct SmsMsgHdr_ST) +
 581                                      sizeof(u32) * 5);
 582
 583                         TriggerMsg->msgData[0] = firmware->StartAddress;
 584                                                 /* Entry point */
 585                         TriggerMsg->msgData[1] = 5; /* Priority */
 586                         TriggerMsg->msgData[2] = 0x200; /* Stack size */
 587                         TriggerMsg->msgData[3] = 0; /* Parameter */
 588                         TriggerMsg->msgData[4] = 4; /* Task ID */
 589
 590                         if (coredev->device_flags & SMS_ROM_NO_RESPONSE) {
 591                                 rc = coredev->sendrequest_handler(
 592                                         coredev->context, TriggerMsg,
 593                                         TriggerMsg->xMsgHeader.msgLength);
 594                                 msleep(100);
 595                         } else
 596                                 rc = smscore_sendrequest_and_wait(
 597                                         coredev, TriggerMsg,
 598                                         TriggerMsg->xMsgHeader.msgLength,
 599                                         &coredev->trigger_done);
 600                 } else {
 601                         SMS_INIT_MSG(msg, MSG_SW_RELOAD_EXEC_REQ,
 602                                      sizeof(struct SmsMsgHdr_ST));
 603
 604                         rc = coredev->sendrequest_handler(coredev->context,
 605                                                           msg, msg->msgLength);
 606                 }
 607                 msleep(500);
 608         }
 609
 610         sms_debug("rc=%d, postload=%p ", rc,
 611                   coredev->postload_handler);
 612
 613         kfree(msg);
 614
 615         return ((rc >= 0) && coredev->postload_handler) ?
 616                 coredev->postload_handler(coredev->context) :
 617                 rc;
 618 }
 619
 620 /**
 621  * loads specified firmware into a buffer and calls device loadfirmware_handler
 622  *
 623  * @param coredev pointer to a coredev object returned by
 624  *                smscore_register_device
 625  * @param filename null-terminated string specifies firmware file name
 626  * @param loadfirmware_handler device handler that loads firmware
 627  *
 628  * @return 0 on success, <0 on error.
 629  */
 630 static int smscore_load_firmware_from_file(struct smscore_device_t *coredev,
 631                                            char *filename,
 632                                            loadfirmware_t loadfirmware_handler)
 633 {
 634         int rc = -ENOENT;
 635         const struct firmware *fw;
 636         u8 *fw_buffer;
 637
 638         if (loadfirmware_handler == NULL && !(coredev->device_flags &
 639                                               SMS_DEVICE_FAMILY2))
 640                 return -EINVAL;
 641
 642         rc = request_firmware(&fw, filename, coredev->device);
 643         if (rc < 0) {
 644                 sms_info("failed to open \"%s\"", filename);
 645                 return rc;
 646         }
 647         sms_info("read FW %s, size=%zd", filename, fw->size);
 648         fw_buffer = kmalloc(ALIGN(fw->size, SMS_ALLOC_ALIGNMENT),
 649                             GFP_KERNEL | GFP_DMA);
 650         if (fw_buffer) {
 651                 memcpy(fw_buffer, fw->data, fw->size);
 652
 653                 rc = (coredev->device_flags & SMS_DEVICE_FAMILY2) ?
 654                       smscore_load_firmware_family2(coredev,
 655                                                     fw_buffer,
 656                                                     fw->size) :
 657                       loadfirmware_handler(coredev->context,
 658                                            fw_buffer, fw->size);
 659
 660                 kfree(fw_buffer);
 661         } else {
 662                 sms_info("failed to allocate firmware buffer");
 663                 rc = -ENOMEM;
 664         }
 665
 666         release_firmware(fw);
 667
 668         return rc;
 669 }
 670
 671 /**
 672  * notifies all clients registered with the device, notifies hotplugs,
 673  * frees all buffers and coredev object
 674  *
 675  * @param coredev pointer to a coredev object returned by
 676  *                smscore_register_device
 677  *
 678  * @return 0 on success, <0 on error.
 679  */
 680 void smscore_unregister_device(struct smscore_device_t *coredev)
 681 {
 682         struct smscore_buffer_t *cb;
 683         int num_buffers = 0;
 684         int retry = 0;
 685
 686         kmutex_lock(&g_smscore_deviceslock);
 687
 688         /* Release input device (IR) resources */
 689         sms_ir_exit(coredev);
 690
 691         smscore_notify_clients(coredev);
 692         smscore_notify_callbacks(coredev, NULL, 0);
 693
 694         /* at this point all buffers should be back
 695          * onresponse must no longer be called */
 696
 697         while (1) {
 698                 while (!list_empty(&coredev->buffers)) {
 699                         cb = (struct smscore_buffer_t *) coredev->buffers.next;
 700                         list_del(&cb->entry);
 701                         kfree(cb);
 702                         num_buffers++;
 703                 }
 704                 if (num_buffers == coredev->num_buffers)
 705                         break;
 706                 if (++retry > 10) {
 707                         sms_info("exiting although "
 708                                  "not all buffers released.");
 709                         break;
 710                 }
 711
 712                 sms_info("waiting for %d buffer(s)",
 713                          coredev->num_buffers - num_buffers);
 714                 msleep(100);
 715         }
 716
 717         sms_info("freed %d buffers", num_buffers);
 718
 719         if (coredev->common_buffer)
 720                 dma_free_coherent(NULL, coredev->common_buffer_size,
 721                         coredev->common_buffer, coredev->common_buffer_phys);
 722
 723         if (coredev->fw_buf != NULL)
 724                 kfree(coredev->fw_buf);
 725
 726         list_del(&coredev->entry);
 727         kfree(coredev);
 728
 729         kmutex_unlock(&g_smscore_deviceslock);
 730
 731         sms_info("device %p destroyed", coredev);
 732 }
 733 EXPORT_SYMBOL_GPL(smscore_unregister_device);
 734
 735 static int smscore_detect_mode(struct smscore_device_t *coredev)
 736 {
 737         void *buffer = kmalloc(sizeof(struct SmsMsgHdr_ST) + SMS_DMA_ALIGNMENT,
 738                                GFP_KERNEL | GFP_DMA);
 739         struct SmsMsgHdr_ST *msg =
 740                 (struct SmsMsgHdr_ST *) SMS_ALIGN_ADDRESS(buffer);
 741         int rc;
 742
 743         if (!buffer)
 744                 return -ENOMEM;
 745
 746         SMS_INIT_MSG(msg, MSG_SMS_GET_VERSION_EX_REQ,
 747                      sizeof(struct SmsMsgHdr_ST));
 748
 749         rc = smscore_sendrequest_and_wait(coredev, msg, msg->msgLength,
 750                                           &coredev->version_ex_done);
 751         if (rc == -ETIME) {
 752                 sms_err("MSG_SMS_GET_VERSION_EX_REQ failed first try");
 753
 754                 if (wait_for_completion_timeout(&coredev->resume_done,
 755                                                 msecs_to_jiffies(5000))) {
 756                         rc = smscore_sendrequest_and_wait(
 757                                 coredev, msg, msg->msgLength,
 758                                 &coredev->version_ex_done);
 759                         if (rc < 0)
 760                                 sms_err("MSG_SMS_GET_VERSION_EX_REQ failed "
 761                                         "second try, rc %d", rc);
 762                 } else
 763                         rc = -ETIME;
 764         }
 765
 766         kfree(buffer);
 767
 768         return rc;
 769 }
 770
 771 static char *smscore_fw_lkup[][SMS_NUM_OF_DEVICE_TYPES] = {
 772         /*Stellar               NOVA A0         Nova B0         VEGA*/
 773         /*DVBT*/
 774         {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"},
 775         /*DVBH*/
 776         {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"},
 777         /*TDMB*/
 778         {"none", "tdmb_nova_12mhz.inp", "tdmb_nova_12mhz_b0.inp", "none"},
 779         /*DABIP*/
 780         {"none", "none", "none", "none"},
 781         /*BDA*/
 782         {"none", "dvb_nova_12mhz.inp", "dvb_nova_12mhz_b0.inp", "none"},
 783         /*ISDBT*/
 784         {"none", "isdbt_nova_12mhz.inp", "isdbt_nova_12mhz_b0.inp", "none"},
 785         /*ISDBTBDA*/
 786         {"none", "isdbt_nova_12mhz.inp", "isdbt_nova_12mhz_b0.inp", "none"},
 787         /*CMMB*/
 788         {"none", "none", "none", "cmmb_vega_12mhz.inp"}
 789 };
 790
 791 static inline char *sms_get_fw_name(struct smscore_device_t *coredev,
 792                                     int mode, enum sms_device_type_st type)
 793 {
 794         char **fw = sms_get_board(smscore_get_board_id(coredev))->fw;
 795         return (fw && fw[mode]) ? fw[mode] : smscore_fw_lkup[mode][type];
 796 }
 797
 798 /**
 799  * calls device handler to change mode of operation
 800  * NOTE: stellar/usb may disconnect when changing mode
 801  *
 802  * @param coredev pointer to a coredev object returned by
 803  *                smscore_register_device
 804  * @param mode requested mode of operation
 805  *
 806  * @return 0 on success, <0 on error.
 807  */
 808 int smscore_set_device_mode(struct smscore_device_t *coredev, int mode)
 809 {
 810         void *buffer;
 811         int rc = 0;
 812         enum sms_device_type_st type;
 813
 814         sms_debug("set device mode to %d", mode);
 815         if (coredev->device_flags & SMS_DEVICE_FAMILY2) {
 816                 if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_RAW_TUNER) {
 817                         sms_err("invalid mode specified %d", mode);
 818                         return -EINVAL;
 819                 }
 820
 821                 smscore_registry_setmode(coredev->devpath, mode);
 822
 823                 if (!(coredev->device_flags & SMS_DEVICE_NOT_READY)) {
 824                         rc = smscore_detect_mode(coredev);
 825                         if (rc < 0) {
 826                                 sms_err("mode detect failed %d", rc);
 827                                 return rc;
 828                         }
 829                 }
 830
 831                 if (coredev->mode == mode) {
 832                         sms_info("device mode %d already set", mode);
 833                         return 0;
 834                 }
 835
 836                 if (!(coredev->modes_supported & (1 << mode))) {
 837                         char *fw_filename;
 838
 839                         type = smscore_registry_gettype(coredev->devpath);
 840                         fw_filename = sms_get_fw_name(coredev, mode, type);
 841
 842                         rc = smscore_load_firmware_from_file(coredev,
 843                                                              fw_filename, NULL);
 844                         if (rc < 0) {
 845                                 sms_warn("error %d loading firmware: %s, "
 846                                          "trying again with default firmware",
 847                                          rc, fw_filename);
 848
 849                                 /* try again with the default firmware */
 850                                 fw_filename = smscore_fw_lkup[mode][type];
 851                                 rc = smscore_load_firmware_from_file(coredev,
 852                                                              fw_filename, NULL);
 853
 854                                 if (rc < 0) {
 855                                         sms_warn("error %d loading "
 856                                                  "firmware: %s", rc,
 857                                                  fw_filename);
 858                                         return rc;
 859                                 }
 860                         }
 861                         sms_log("firmware download success: %s", fw_filename);
 862                 } else
 863                         sms_info("mode %d supported by running "
 864                                  "firmware", mode);
 865
 866                 buffer = kmalloc(sizeof(struct SmsMsgData_ST) +
 867                                  SMS_DMA_ALIGNMENT, GFP_KERNEL | GFP_DMA);
 868                 if (buffer) {
 869                         struct SmsMsgData_ST *msg =
 870                                 (struct SmsMsgData_ST *)
 871                                         SMS_ALIGN_ADDRESS(buffer);
 872
 873                         SMS_INIT_MSG(&msg->xMsgHeader, MSG_SMS_INIT_DEVICE_REQ,
 874                                      sizeof(struct SmsMsgData_ST));
 875                         msg->msgData[0] = mode;
 876
 877                         rc = smscore_sendrequest_and_wait(
 878                                 coredev, msg, msg->xMsgHeader.msgLength,
 879                                 &coredev->init_device_done);
 880
 881                         kfree(buffer);
 882                 } else {
 883                         sms_err("Could not allocate buffer for "
 884                                 "init device message.");
 885                         rc = -ENOMEM;
 886                 }
 887         } else {
 888                 if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) {
 889                         sms_err("invalid mode specified %d", mode);
 890                         return -EINVAL;
 891                 }
 892
 893                 smscore_registry_setmode(coredev->devpath, mode);
 894
 895                 if (coredev->detectmode_handler)
 896                         coredev->detectmode_handler(coredev->context,
 897                                                     &coredev->mode);
 898
 899                 if (coredev->mode != mode && coredev->setmode_handler)
 900                         rc = coredev->setmode_handler(coredev->context, mode);
 901         }
 902
 903         if (rc >= 0) {
 904                 coredev->mode = mode;
 905                 coredev->device_flags &= ~SMS_DEVICE_NOT_READY;
 906         }
 907
 908         if (rc < 0)
 909                 sms_err("return error code %d.", rc);
 910         return rc;
 911 }
 912
 913 /**
 914  * calls device handler to get current mode of operation
 915  *
 916  * @param coredev pointer to a coredev object returned by
 917  *                smscore_register_device
 918  *
 919  * @return current mode
 920  */
 921 int smscore_get_device_mode(struct smscore_device_t *coredev)
 922 {
 923         return coredev->mode;
 924 }
 925 EXPORT_SYMBOL_GPL(smscore_get_device_mode);
 926
 927 /**
 928  * find client by response id & type within the clients list.
 929  * return client handle or NULL.
 930  *
 931  * @param coredev pointer to a coredev object returned by
 932  *                smscore_register_device
 933  * @param data_type client data type (SMS_DONT_CARE for all types)
 934  * @param id client id (SMS_DONT_CARE for all id)
 935  *
 936  */
 937 static struct
 938 smscore_client_t *smscore_find_client(struct smscore_device_t *coredev,
 939                                       int data_type, int id)
 940 {
 941         struct smscore_client_t *client = NULL;
 942         struct list_head *next, *first;
 943         unsigned long flags;
 944         struct list_head *firstid, *nextid;
 945
 946
 947         spin_lock_irqsave(&coredev->clientslock, flags);
 948         first = &coredev->clients;
 949         for (next = first->next;
 950              (next != first) && !client;
 951              next = next->next) {
 952                 firstid = &((struct smscore_client_t *)next)->idlist;
 953                 for (nextid = firstid->next;
 954                      nextid != firstid;
 955                      nextid = nextid->next) {
 956                         if ((((struct smscore_idlist_t *)nextid)->id == id) &&
 957                             (((struct smscore_idlist_t *)nextid)->data_type == data_type ||
 958                             (((struct smscore_idlist_t *)nextid)->data_type == 0))) {
 959                                 client = (struct smscore_client_t *) next;
 960                                 break;
 961                         }
 962                 }
 963         }
 964         spin_unlock_irqrestore(&coredev->clientslock, flags);
 965         return client;
 966 }
 967
 968 /**
 969  * find client by response id/type, call clients onresponse handler
 970  * return buffer to pool on error
 971  *
 972  * @param coredev pointer to a coredev object returned by
 973  *                smscore_register_device
 974  * @param cb pointer to response buffer descriptor
 975  *
 976  */
 977 void smscore_onresponse(struct smscore_device_t *coredev,
 978                 struct smscore_buffer_t *cb) {
 979         struct SmsMsgHdr_ST *phdr = (struct SmsMsgHdr_ST *) ((u8 *) cb->p
 980                         + cb->offset);
 981         struct smscore_client_t *client;
 982         int rc = -EBUSY;
 983         static unsigned long last_sample_time; /* = 0; */
 984         static int data_total; /* = 0; */
 985         unsigned long time_now = jiffies_to_msecs(jiffies);
 986
 987         if (!last_sample_time)
 988                 last_sample_time = time_now;
 989
 990         if (time_now - last_sample_time > 10000) {
 991                 sms_debug("\ndata rate %d bytes/secs",
 992                           (int)((data_total * 1000) /
 993                                 (time_now - last_sample_time)));
 994
 995                 last_sample_time = time_now;
 996                 data_total = 0;
 997         }
 998
 999         data_total += cb->size;
1000         /* Do we need to re-route? */
1001         if ((phdr->msgType == MSG_SMS_HO_PER_SLICES_IND) ||
1002                         (phdr->msgType == MSG_SMS_TRANSMISSION_IND)) {
1003                 if (coredev->mode == DEVICE_MODE_DVBT_BDA)
1004                         phdr->msgDstId = DVBT_BDA_CONTROL_MSG_ID;
1005         }
1006
1007
1008         client = smscore_find_client(coredev, phdr->msgType, phdr->msgDstId);
1009
1010         /* If no client registered for type & id,
1011          * check for control client where type is not registered */
1012         if (client)
1013                 rc = client->onresponse_handler(client->context, cb);
1014
1015         if (rc < 0) {
1016                 switch (phdr->msgType) {
1017                 case MSG_SMS_GET_VERSION_EX_RES:
1018                 {
1019                         struct SmsVersionRes_ST *ver =
1020                                 (struct SmsVersionRes_ST *) phdr;
1021                         sms_debug("MSG_SMS_GET_VERSION_EX_RES "
1022                                   "id %d prots 0x%x ver %d.%d",
1023                                   ver->FirmwareId, ver->SupportedProtocols,
1024                                   ver->RomVersionMajor, ver->RomVersionMinor);
1025
1026                         coredev->mode = ver->FirmwareId == 255 ?
1027                                 DEVICE_MODE_NONE : ver->FirmwareId;
1028                         coredev->modes_supported = ver->SupportedProtocols;
1029
1030                         complete(&coredev->version_ex_done);
1031                         break;
1032                 }
1033                 case MSG_SMS_INIT_DEVICE_RES:
1034                         sms_debug("MSG_SMS_INIT_DEVICE_RES");
1035                         complete(&coredev->init_device_done);
1036                         break;
1037                 case MSG_SW_RELOAD_START_RES:
1038                         sms_debug("MSG_SW_RELOAD_START_RES");
1039                         complete(&coredev->reload_start_done);
1040                         break;
1041                 case MSG_SMS_DATA_DOWNLOAD_RES:
1042                         complete(&coredev->data_download_done);
1043                         break;
1044                 case MSG_SW_RELOAD_EXEC_RES:
1045                         sms_debug("MSG_SW_RELOAD_EXEC_RES");
1046                         break;
1047                 case MSG_SMS_SWDOWNLOAD_TRIGGER_RES:
1048                         sms_debug("MSG_SMS_SWDOWNLOAD_TRIGGER_RES");
1049                         complete(&coredev->trigger_done);
1050                         break;
1051                 case MSG_SMS_SLEEP_RESUME_COMP_IND:
1052                         complete(&coredev->resume_done);
1053                         break;
1054                 case MSG_SMS_START_IR_RES:
1055                         complete(&coredev->ir_init_done);
1056                         break;
1057                 case MSG_SMS_IR_SAMPLES_IND:
1058                         sms_ir_event(coredev,
1059                                 (const char *)
1060                                 ((char *)phdr
1061                                 + sizeof(struct SmsMsgHdr_ST)),
1062                                 (int)phdr->msgLength
1063                                 - sizeof(struct SmsMsgHdr_ST));
1064                         break;
1065
1066                 default:
1067                         break;
1068                 }
1069                 smscore_putbuffer(coredev, cb);
1070         }
1071 }
1072 EXPORT_SYMBOL_GPL(smscore_onresponse);
1073
1074 /**
1075  * return pointer to next free buffer descriptor from core pool
1076  *
1077  * @param coredev pointer to a coredev object returned by
1078  *                smscore_register_device
1079  *
1080  * @return pointer to descriptor on success, NULL on error.
1081  */
1082 struct smscore_buffer_t *smscore_getbuffer(struct smscore_device_t *coredev)
1083 {
1084         struct smscore_buffer_t *cb = NULL;
1085         unsigned long flags;
1086
1087         DEFINE_WAIT(wait);
1088
1089         spin_lock_irqsave(&coredev->bufferslock, flags);
1090
1091         /* This function must return a valid buffer, since the buffer list is
1092          * finite, we check that there is an available buffer, if not, we wait
1093          * until such buffer become available.
1094          */
1095
1096         prepare_to_wait(&coredev->buffer_mng_waitq, &wait, TASK_INTERRUPTIBLE);
1097
1098         if (list_empty(&coredev->buffers))
1099                 schedule();
1100
1101         finish_wait(&coredev->buffer_mng_waitq, &wait);
1102
1103         cb = (struct smscore_buffer_t *) coredev->buffers.next;
1104         list_del(&cb->entry);
1105
1106         spin_unlock_irqrestore(&coredev->bufferslock, flags);
1107
1108         return cb;
1109 }
1110 EXPORT_SYMBOL_GPL(smscore_getbuffer);
1111
1112 /**
1113  * return buffer descriptor to a pool
1114  *
1115  * @param coredev pointer to a coredev object returned by
1116  *                smscore_register_device
1117  * @param cb pointer buffer descriptor
1118  *
1119  */
1120 void smscore_putbuffer(struct smscore_device_t *coredev,
1121                 struct smscore_buffer_t *cb) {
1122         wake_up_interruptible(&coredev->buffer_mng_waitq);
1123         list_add_locked(&cb->entry, &coredev->buffers, &coredev->bufferslock);
1124 }
1125 EXPORT_SYMBOL_GPL(smscore_putbuffer);
1126
1127 static int smscore_validate_client(struct smscore_device_t *coredev,
1128                                    struct smscore_client_t *client,
1129                                    int data_type, int id)
1130 {
1131         struct smscore_idlist_t *listentry;
1132         struct smscore_client_t *registered_client;
1133
1134         if (!client) {
1135                 sms_err("bad parameter.");
1136                 return -EFAULT;
1137         }
1138         registered_client = smscore_find_client(coredev, data_type, id);
1139         if (registered_client == client)
1140                 return 0;
1141
1142         if (registered_client) {
1143                 sms_err("The msg ID already registered to another client.");
1144                 return -EEXIST;
1145         }
1146         listentry = kzalloc(sizeof(struct smscore_idlist_t), GFP_KERNEL);
1147         if (!listentry) {
1148                 sms_err("Can't allocate memory for client id.");
1149                 return -ENOMEM;
1150         }
1151         listentry->id = id;
1152         listentry->data_type = data_type;
1153         list_add_locked(&listentry->entry, &client->idlist,
1154                         &coredev->clientslock);
1155         return 0;
1156 }
1157
1158 /**
1159  * creates smsclient object, check that id is taken by another client
1160  *
1161  * @param coredev pointer to a coredev object from clients hotplug
1162  * @param initial_id all messages with this id would be sent to this client
1163  * @param data_type all messages of this type would be sent to this client
1164  * @param onresponse_handler client handler that is called to
1165  *                           process incoming messages
1166  * @param onremove_handler client handler that is called when device is removed
1167  * @param context client-specific context
1168  * @param client pointer to a value that receives created smsclient object
1169  *
1170  * @return 0 on success, <0 on error.
1171  */
1172 int smscore_register_client(struct smscore_device_t *coredev,
1173                             struct smsclient_params_t *params,
1174                             struct smscore_client_t **client)
1175 {
1176         struct smscore_client_t *newclient;
1177         /* check that no other channel with same parameters exists */
1178         if (smscore_find_client(coredev, params->data_type,
1179                                 params->initial_id)) {
1180                 sms_err("Client already exist.");
1181                 return -EEXIST;
1182         }
1183
1184         newclient = kzalloc(sizeof(struct smscore_client_t), GFP_KERNEL);
1185         if (!newclient) {
1186                 sms_err("Failed to allocate memory for client.");
1187                 return -ENOMEM;
1188         }
1189
1190         INIT_LIST_HEAD(&newclient->idlist);
1191         newclient->coredev = coredev;
1192         newclient->onresponse_handler = params->onresponse_handler;
1193         newclient->onremove_handler = params->onremove_handler;
1194         newclient->context = params->context;
1195         list_add_locked(&newclient->entry, &coredev->clients,
1196                         &coredev->clientslock);
1197         smscore_validate_client(coredev, newclient, params->data_type,
1198                                 params->initial_id);
1199         *client = newclient;
1200         sms_debug("%p %d %d", params->context, params->data_type,
1201                   params->initial_id);
1202
1203         return 0;
1204 }
1205 EXPORT_SYMBOL_GPL(smscore_register_client);
1206
1207 /**
1208  * frees smsclient object and all subclients associated with it
1209  *
1210  * @param client pointer to smsclient object returned by
1211  *               smscore_register_client
1212  *
1213  */
1214 void smscore_unregister_client(struct smscore_client_t *client)
1215 {
1216         struct smscore_device_t *coredev = client->coredev;
1217         unsigned long flags;
1218
1219         spin_lock_irqsave(&coredev->clientslock, flags);
1220
1221
1222         while (!list_empty(&client->idlist)) {
1223                 struct smscore_idlist_t *identry =
1224                         (struct smscore_idlist_t *) client->idlist.next;
1225                 list_del(&identry->entry);
1226                 kfree(identry);
1227         }
1228
1229         sms_info("%p", client->context);
1230
1231         list_del(&client->entry);
1232         kfree(client);
1233
1234         spin_unlock_irqrestore(&coredev->clientslock, flags);
1235 }
1236 EXPORT_SYMBOL_GPL(smscore_unregister_client);
1237
1238 /**
1239  * verifies that source id is not taken by another client,
1240  * calls device handler to send requests to the device
1241  *
1242  * @param client pointer to smsclient object returned by
1243  *               smscore_register_client
1244  * @param buffer pointer to a request buffer
1245  * @param size size (in bytes) of request buffer
1246  *
1247  * @return 0 on success, <0 on error.
1248  */
1249 int smsclient_sendrequest(struct smscore_client_t *client,
1250                           void *buffer, size_t size)
1251 {
1252         struct smscore_device_t *coredev;
1253         struct SmsMsgHdr_ST *phdr = (struct SmsMsgHdr_ST *) buffer;
1254         int rc;
1255
1256         if (client == NULL) {
1257                 sms_err("Got NULL client");
1258                 return -EINVAL;
1259         }
1260
1261         coredev = client->coredev;
1262
1263         /* check that no other channel with same id exists */
1264         if (coredev == NULL) {
1265                 sms_err("Got NULL coredev");
1266                 return -EINVAL;
1267         }
1268
1269         rc = smscore_validate_client(client->coredev, client, 0,
1270                                      phdr->msgSrcId);
1271         if (rc < 0)
1272                 return rc;
1273
1274         return coredev->sendrequest_handler(coredev->context, buffer, size);
1275 }
1276 EXPORT_SYMBOL_GPL(smsclient_sendrequest);
1277
1278
1279 /* old GPIO managments implementation */
1280 int smscore_configure_gpio(struct smscore_device_t *coredev, u32 pin,
1281                            struct smscore_config_gpio *pinconfig)
1282 {
1283         struct {
1284                 struct SmsMsgHdr_ST hdr;
1285                 u32 data[6];
1286         } msg;
1287
1288         if (coredev->device_flags & SMS_DEVICE_FAMILY2) {
1289                 msg.hdr.msgSrcId = DVBT_BDA_CONTROL_MSG_ID;
1290                 msg.hdr.msgDstId = HIF_TASK;
1291                 msg.hdr.msgFlags = 0;
1292                 msg.hdr.msgType  = MSG_SMS_GPIO_CONFIG_EX_REQ;
1293                 msg.hdr.msgLength = sizeof(msg);
1294
1295                 msg.data[0] = pin;
1296                 msg.data[1] = pinconfig->pullupdown;
1297
1298                 /* Convert slew rate for Nova: Fast(0) = 3 / Slow(1) = 0; */
1299                 msg.data[2] = pinconfig->outputslewrate == 0 ? 3 : 0;
1300
1301                 switch (pinconfig->outputdriving) {
1302                 case SMS_GPIO_OUTPUTDRIVING_16mA:
1303                         msg.data[3] = 7; /* Nova - 16mA */
1304                         break;
1305                 case SMS_GPIO_OUTPUTDRIVING_12mA:
1306                         msg.data[3] = 5; /* Nova - 11mA */
1307                         break;
1308                 case SMS_GPIO_OUTPUTDRIVING_8mA:
1309                         msg.data[3] = 3; /* Nova - 7mA */
1310                         break;
1311                 case SMS_GPIO_OUTPUTDRIVING_4mA:
1312                 default:
1313                         msg.data[3] = 2; /* Nova - 4mA */
1314                         break;
1315                 }
1316
1317                 msg.data[4] = pinconfig->direction;
1318                 msg.data[5] = 0;
1319         } else /* TODO: SMS_DEVICE_FAMILY1 */
1320                 return -EINVAL;
1321
1322         return coredev->sendrequest_handler(coredev->context,
1323                                             &msg, sizeof(msg));
1324 }
1325
1326 int smscore_set_gpio(struct smscore_device_t *coredev, u32 pin, int level)
1327 {
1328         struct {
1329                 struct SmsMsgHdr_ST hdr;
1330                 u32 data[3];
1331         } msg;
1332
1333         if (pin > MAX_GPIO_PIN_NUMBER)
1334                 return -EINVAL;
1335
1336         msg.hdr.msgSrcId = DVBT_BDA_CONTROL_MSG_ID;
1337         msg.hdr.msgDstId = HIF_TASK;
1338         msg.hdr.msgFlags = 0;
1339         msg.hdr.msgType  = MSG_SMS_GPIO_SET_LEVEL_REQ;
1340         msg.hdr.msgLength = sizeof(msg);
1341
1342         msg.data[0] = pin;
1343         msg.data[1] = level ? 1 : 0;
1344         msg.data[2] = 0;
1345
1346         return coredev->sendrequest_handler(coredev->context,
1347                                             &msg, sizeof(msg));
1348 }
1349
1350 /* new GPIO managment implementation */
1351 static int GetGpioPinParams(u32 PinNum, u32 *pTranslatedPinNum,
1352                 u32 *pGroupNum, u32 *pGroupCfg) {
1353
1354         *pGroupCfg = 1;
1355
1356         if (PinNum >= 0 && PinNum <= 1) {
1357                 *pTranslatedPinNum = 0;
1358                 *pGroupNum = 9;
1359                 *pGroupCfg = 2;
1360         } else if (PinNum >= 2 && PinNum <= 6) {
1361                 *pTranslatedPinNum = 2;
1362                 *pGroupNum = 0;
1363                 *pGroupCfg = 2;
1364         } else if (PinNum >= 7 && PinNum <= 11) {
1365                 *pTranslatedPinNum = 7;
1366                 *pGroupNum = 1;
1367         } else if (PinNum >= 12 && PinNum <= 15) {
1368                 *pTranslatedPinNum = 12;
1369                 *pGroupNum = 2;
1370                 *pGroupCfg = 3;
1371         } else if (PinNum == 16) {
1372                 *pTranslatedPinNum = 16;
1373                 *pGroupNum = 23;
1374         } else if (PinNum >= 17 && PinNum <= 24) {
1375                 *pTranslatedPinNum = 17;
1376                 *pGroupNum = 3;
1377         } else if (PinNum == 25) {
1378                 *pTranslatedPinNum = 25;
1379                 *pGroupNum = 6;
1380         } else if (PinNum >= 26 && PinNum <= 28) {
1381                 *pTranslatedPinNum = 26;
1382                 *pGroupNum = 4;
1383         } else if (PinNum == 29) {
1384                 *pTranslatedPinNum = 29;
1385                 *pGroupNum = 5;
1386                 *pGroupCfg = 2;
1387         } else if (PinNum == 30) {
1388                 *pTranslatedPinNum = 30;
1389                 *pGroupNum = 8;
1390         } else if (PinNum == 31) {
1391                 *pTranslatedPinNum = 31;
1392                 *pGroupNum = 17;
1393         } else
1394                 return -1;
1395
1396         *pGroupCfg <<= 24;
1397
1398         return 0;
1399 }
1400
1401 int smscore_gpio_configure(struct smscore_device_t *coredev, u8 PinNum,
1402                 struct smscore_gpio_config *pGpioConfig) {
1403
1404         u32 totalLen;
1405         u32 TranslatedPinNum;
1406         u32 GroupNum;
1407         u32 ElectricChar;
1408         u32 groupCfg;
1409         void *buffer;
1410         int rc;
1411
1412         struct SetGpioMsg {
1413                 struct SmsMsgHdr_ST xMsgHeader;
1414                 u32 msgData[6];
1415         } *pMsg;
1416
1417
1418         if (PinNum > MAX_GPIO_PIN_NUMBER)
1419                 return -EINVAL;
1420
1421         if (pGpioConfig == NULL)
1422                 return -EINVAL;
1423
1424         totalLen = sizeof(struct SmsMsgHdr_ST) + (sizeof(u32) * 6);
1425
1426         buffer = kmalloc(totalLen + SMS_DMA_ALIGNMENT,
1427                         GFP_KERNEL | GFP_DMA);
1428         if (!buffer)
1429                 return -ENOMEM;
1430
1431         pMsg = (struct SetGpioMsg *) SMS_ALIGN_ADDRESS(buffer);
1432
1433         pMsg->xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID;
1434         pMsg->xMsgHeader.msgDstId = HIF_TASK;
1435         pMsg->xMsgHeader.msgFlags = 0;
1436         pMsg->xMsgHeader.msgLength = (u16) totalLen;
1437         pMsg->msgData[0] = PinNum;
1438
1439         if (!(coredev->device_flags & SMS_DEVICE_FAMILY2)) {
1440                 pMsg->xMsgHeader.msgType = MSG_SMS_GPIO_CONFIG_REQ;
1441                 if (GetGpioPinParams(PinNum, &TranslatedPinNum, &GroupNum,
1442                                 &groupCfg) != 0)
1443                         return -EINVAL;
1444
1445                 pMsg->msgData[1] = TranslatedPinNum;
1446                 pMsg->msgData[2] = GroupNum;
1447                 ElectricChar = (pGpioConfig->PullUpDown)
1448                                 | (pGpioConfig->InputCharacteristics << 2)
1449                                 | (pGpioConfig->OutputSlewRate << 3)
1450                                 | (pGpioConfig->OutputDriving << 4);
1451                 pMsg->msgData[3] = ElectricChar;
1452                 pMsg->msgData[4] = pGpioConfig->Direction;
1453                 pMsg->msgData[5] = groupCfg;
1454         } else {
1455                 pMsg->xMsgHeader.msgType = MSG_SMS_GPIO_CONFIG_EX_REQ;
1456                 pMsg->msgData[1] = pGpioConfig->PullUpDown;
1457                 pMsg->msgData[2] = pGpioConfig->OutputSlewRate;
1458                 pMsg->msgData[3] = pGpioConfig->OutputDriving;
1459                 pMsg->msgData[4] = pGpioConfig->Direction;
1460                 pMsg->msgData[5] = 0;
1461         }
1462
1463         smsendian_handle_tx_message((struct SmsMsgHdr_ST *)pMsg);
1464         rc = smscore_sendrequest_and_wait(coredev, pMsg, totalLen,
1465                         &coredev->gpio_configuration_done);
1466
1467         if (rc != 0) {
1468                 if (rc == -ETIME)
1469                         sms_err("smscore_gpio_configure timeout");
1470                 else
1471                         sms_err("smscore_gpio_configure error");
1472         }
1473         kfree(buffer);
1474
1475         return rc;
1476 }
1477
1478 int smscore_gpio_set_level(struct smscore_device_t *coredev, u8 PinNum,
1479                 u8 NewLevel) {
1480
1481         u32 totalLen;
1482         int rc;
1483         void *buffer;
1484
1485         struct SetGpioMsg {
1486                 struct SmsMsgHdr_ST xMsgHeader;
1487                 u32 msgData[3]; /* keep it 3 ! */
1488         } *pMsg;
1489
1490         if ((NewLevel > 1) || (PinNum > MAX_GPIO_PIN_NUMBER) ||
1491                         (PinNum > MAX_GPIO_PIN_NUMBER))
1492                 return -EINVAL;
1493
1494         totalLen = sizeof(struct SmsMsgHdr_ST) +
1495                         (3 * sizeof(u32)); /* keep it 3 ! */
1496
1497         buffer = kmalloc(totalLen + SMS_DMA_ALIGNMENT,
1498                         GFP_KERNEL | GFP_DMA);
1499         if (!buffer)
1500                 return -ENOMEM;
1501
1502         pMsg = (struct SetGpioMsg *) SMS_ALIGN_ADDRESS(buffer);
1503
1504         pMsg->xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID;
1505         pMsg->xMsgHeader.msgDstId = HIF_TASK;
1506         pMsg->xMsgHeader.msgFlags = 0;
1507         pMsg->xMsgHeader.msgType = MSG_SMS_GPIO_SET_LEVEL_REQ;
1508         pMsg->xMsgHeader.msgLength = (u16) totalLen;
1509         pMsg->msgData[0] = PinNum;
1510         pMsg->msgData[1] = NewLevel;
1511
1512         /* Send message to SMS */
1513         smsendian_handle_tx_message((struct SmsMsgHdr_ST *)pMsg);
1514         rc = smscore_sendrequest_and_wait(coredev, pMsg, totalLen,
1515                         &coredev->gpio_set_level_done);
1516
1517         if (rc != 0) {
1518                 if (rc == -ETIME)
1519                         sms_err("smscore_gpio_set_level timeout");
1520                 else
1521                         sms_err("smscore_gpio_set_level error");
1522         }
1523         kfree(buffer);
1524
1525         return rc;
1526 }
1527
1528 int smscore_gpio_get_level(struct smscore_device_t *coredev, u8 PinNum,
1529                 u8 *level) {
1530
1531         u32 totalLen;
1532         int rc;
1533         void *buffer;
1534
1535         struct SetGpioMsg {
1536                 struct SmsMsgHdr_ST xMsgHeader;
1537                 u32 msgData[2];
1538         } *pMsg;
1539
1540
1541         if (PinNum > MAX_GPIO_PIN_NUMBER)
1542                 return -EINVAL;
1543
1544         totalLen = sizeof(struct SmsMsgHdr_ST) + (2 * sizeof(u32));
1545
1546         buffer = kmalloc(totalLen + SMS_DMA_ALIGNMENT,
1547                         GFP_KERNEL | GFP_DMA);
1548         if (!buffer)
1549                 return -ENOMEM;
1550
1551         pMsg = (struct SetGpioMsg *) SMS_ALIGN_ADDRESS(buffer);
1552
1553         pMsg->xMsgHeader.msgSrcId = DVBT_BDA_CONTROL_MSG_ID;
1554         pMsg->xMsgHeader.msgDstId = HIF_TASK;
1555         pMsg->xMsgHeader.msgFlags = 0;
1556         pMsg->xMsgHeader.msgType = MSG_SMS_GPIO_GET_LEVEL_REQ;
1557         pMsg->xMsgHeader.msgLength = (u16) totalLen;
1558         pMsg->msgData[0] = PinNum;
1559         pMsg->msgData[1] = 0;
1560
1561         /* Send message to SMS */
1562         smsendian_handle_tx_message((struct SmsMsgHdr_ST *)pMsg);
1563         rc = smscore_sendrequest_and_wait(coredev, pMsg, totalLen,
1564                         &coredev->gpio_get_level_done);
1565
1566         if (rc != 0) {
1567                 if (rc == -ETIME)
1568                         sms_err("smscore_gpio_get_level timeout");
1569                 else
1570                         sms_err("smscore_gpio_get_level error");
1571         }
1572         kfree(buffer);
1573
1574         /* Its a race between other gpio_get_level() and the copy of the single
1575          * global 'coredev->gpio_get_res' to  the function's variable 'level'
1576          */
1577         *level = coredev->gpio_get_res;
1578
1579         return rc;
1580 }
1581
1582 static int __init smscore_module_init(void)
1583 {
1584         int rc = 0;
1585
1586         INIT_LIST_HEAD(&g_smscore_notifyees);
1587         INIT_LIST_HEAD(&g_smscore_devices);
1588         kmutex_init(&g_smscore_deviceslock);
1589
1590         INIT_LIST_HEAD(&g_smscore_registry);
1591         kmutex_init(&g_smscore_registrylock);
1592
1593
1594
1595
1596
1597
1598         return rc;
1599         sms_debug("rc %d", rc);
1600
1601         return rc;
1602 }
1603
1604 static void __exit smscore_module_exit(void)
1605 {
1606
1607
1608
1609
1610
1611         kmutex_lock(&g_smscore_deviceslock);
1612         while (!list_empty(&g_smscore_notifyees)) {
1613                 struct smscore_device_notifyee_t *notifyee =
1614                         (struct smscore_device_notifyee_t *)
1615                                 g_smscore_notifyees.next;
1616
1617                 list_del(&notifyee->entry);
1618                 kfree(notifyee);
1619         }
1620         kmutex_unlock(&g_smscore_deviceslock);
1621
1622         kmutex_lock(&g_smscore_registrylock);
1623         while (!list_empty(&g_smscore_registry)) {
1624                 struct smscore_registry_entry_t *entry =
1625                         (struct smscore_registry_entry_t *)
1626                                 g_smscore_registry.next;
1627
1628                 list_del(&entry->entry);
1629                 kfree(entry);
1630         }
1631         kmutex_unlock(&g_smscore_registrylock);
1632
1633         sms_debug("");
1634 }
1635
1636 module_init(smscore_module_init);
1637 module_exit(smscore_module_exit);
1638
1639 MODULE_DESCRIPTION("Siano MDTV Core module");
1640 MODULE_AUTHOR("Siano Mobile Silicon, Inc. (uris@siano-ms.com)");
1641 MODULE_LICENSE("GPL");