Introduction to USB:

These days we are using USB(Universal Serial Bus) devices like pen drive

,mouse,printer etc instead of using serial or parallel port devices. One of the original intentions of USB was to reduce the amount of cabling at the back of your PC. USB port can connect up to 127 peripheral devices by using hub. Averagely it gives us 12Mbps data transfer speed.

Basically host controller keep checking at the USB port to detect device. Whenever device came due to voltage difference it generate interrupt and inform to the system about the device.

Now to make USB communication between the host and the device there is need of the drivers on the both side.In our system there is core usb driver which load the appropriate interfacing driver (that is of our concern )for the usb device (mouse ,keyboard etc.) for service. In our system there are different different drivers for different type of devices to make core driver less bulky.

USB device basic:

USB device may have one or more configurations and each configuration consist of one or more interfaces and each interfaces consist of one or more endpoints. Generally there is only one configuration in more devices if more, then it will be select able by hardware switch. In our GSM modem there is facility of attaching storage device also so it has two interfaces.

Now for communication we have to send or receive data from the endpoints which is inside the interface ,these may be input endpoint or output endpoint for receiving and sending respectively.

Type of data transfer from endpoint:

Control :

Control endpoint is used to retrieve the device information at the time of enumeration of device

Enumeration is the process in which core driver take the information about the hardware from the device firmware to check the vendor id,product id ,serial number etc to load appropriate interfacing driver to serve.

Interrupt:

Interrupt endpoint is used to send the small data of in asynchronous manner like in keyboard. This endpoint is not used to transfer large amount of data.

Isochronous:

Isochronous endpoint is used to send large amount of data but it is generally used where we can accept some data loss like in video streaming where continuous stream of data is required.

Bulk:

Bulk endpoint is also used to send large amount of data and there is no loss in the data. It is used for the mass storage devices to copy the data to and from t he system. It split the data into small chunks if there is large amount of data according to the block size.

Now it is clear from above discussion that data is transferred from the endpoint. Data is generally transferred in URBs i.e USB request blocks.

Interfacing Driver:

Interfacing driver means that driver which is loaded by usb core driver for specific device to server. It communicate between the application layer and the usb core driver to serve the device request. If we want to use our interfacing driver in the system to provide service then we have to register our driver with USB subsystem first using usb_register() system call and then in our driver we also have to specify that our driver is made for which device (vendor id, product id etc.). All these information is provided in the linux/usb.h header file.

Now one important thing is that you have to remove the usbhid named driver from the system using rmmod usbhid if it is moduler otherwise recompile raw kernel by making hid(human interface device) driver moduler from static.

Thank you.

Socket:

Sockets are basically used for inter process communication within single or over the network systems. So sockets are basically two endpoints of the communication via which we can communicate. So socket represents a single connection between exactly two pieces of software but we can also communicate between multiple piece of softwares but this requires multiple sockets.

*Sockets are use of unidirectional as well as bidirectional communication.

Now as we know if we have to work on the network then we have to deal with IP addresses also because each and every system on the network is recognized by its IP address.In this we have one server and many clients to take the service of the server. Notice that the client needs to know the existence of and the address of the server, but the server does not need to know the address of (or even the existence of) the client prior to the connection being established. Notice also that once a connection is established, both sides can send and receive information.

Socket Types:

There are two widely used socket types, stream sockets, and datagram sockets. Stream sockets treat communications as a continuous stream of characters, while datagram sockets have to read entire messages at once. Each uses its own communications protocol. Stream sockets use TCP (Transmission Control Protocol), which is a reliable, stream oriented protocol, and datagram sockets use UDP (Unix Datagram Protocol), which is unreliable and message oriented.

The address of a socket in the Internet domain consists of the Internet address of the host machine (a unique 32 bit address, often referred to as its IP address). In addition, each socket needs a port number on that host. Port numbers are 16 bit unsigned integers. The lower numbers are reserved in Unix for standard services. For example, the port number for the FTP server is 21. It is important that standard services be at the same port on all computers so that clients will know their addresses. However, port numbers above 2000 are generally available.

API to establish socket:

In server side:

Socket system calls are declaired in the linux system at standard path in the <sys/socket.h> header file.

Firstly we have to make socket with socket() call. When a socket is created, the program has to specify the address domain and the socket type. Two processes can communicate with each other only if their sockets are of the same type and in the same domain. There are two widely used address domains, the unix domain, in which two processes which share a common file system communicate, and the Internet domain, in which two processes running on any two hosts on the Internet communicate. Each of these has its own address format.

Bind the socket to an address using the bind() system call. For a server socket on the Internet, an address consists of a port number on the host machine.

Listen for connections with the listen() system call

Accept a connection with the accept() system call. This call typically blocks until a client connects with the server.

In client side:

In the client side also we have to make socket,Connect the socket to the address of the server using the connect() system call

Send and receive data. There are a number of ways to do this, but the simplest is to use the read() and write() system calls.

We can check our client and server program by loopback means by giving the IP address “127.0.0.1”.

on client and server side on single system.

Thanks

Avtar Singh

Embedded OS:

Embedded Operating System is simply a light version of complete OS ,means in embedded OS we reduce some functionality from the OS according to the our requirement like if we don’t want to use the USB camera then we disable it. We can put applications according to the requirement which decrease the overhead of OS.

Porting:

Porting is the process in which we put compiled software in the target machine (in my case arm based olinuxino board )after developing it on the host machine like x86.

Note: I have used x86 machine for development because it is faster than the ARM based system.

Why Olinuxino Board???

Many boards are used for development purpose but i have used Olinuxino board ( by Olimex )due to below positive points:

Open source

Open hardware

Complete documentation is freely available on the network.

Some main features:

1.Ghz Processor(A13 Cortex A8 by Allwinner Technologies China) speed.

2.3D mali 400 GPU.

3.VGA video output.

4.Touch screen interface.

5.512 MB RAM

6.GPIO pins.

7.SD card slot.

Primary Requirements for Board Bring Up:

For standing up our system we need below softwares.

1.Tool chain

2.Secound stage boot loader(u-boot)

3.Kernel Image(uImage)

4.Debian Root file system.

*All the above packages are free available on the internet to download.

Brief Note On development Process:

Tool chain is used to cross compile all the packages on the x86 machine according to the ARM based system.

So I cross compiled firstly kernel before selecting required functionalitie by menuconfig.

After that I cross compile U-boot which is second stage boot loader and required to load the kernel image on the RAM for execution.

Card Partitioning:

Card partitioning is essential in the board bringing up to partition the card and making appropriate file system because at the initial stage of the system boot up ,system can’t support the heavy file system like ext 2 or ext3 due to absence of kernel.

So we make first partition of 16MB of vfat file system and rest memory of ext3 file system.

I partitioned the card using “fdisk” utility.

Porting On MMC Card:

1.Using “dd” command i placed the sunxi-spl.bin and u-boot.bin from the u-boot to the unpartitioned space which is after the 8kb and before 1MB respectively.

2.Now I simply copied the uImage and script.bin to the first partition of 16MB

3.At last in the secound partition i uncompressed the archive image of debian root file system.

After this my card was ready to boot up on the olinuxino board

Thanks

Avtar Singh

also practice some program using inline function.

some problems are comming in 9th assignment.

Also done 1 assignment of c++.

main problem is coming in low level file input-output operations.

DEVICE DRIVER IMPLEMENTATION ROUTE MAP:
I firstly used two predefined macros named as module_init(entry_function) and module_exit(exit_function) as entrance point as main() in user space and exit point respectively.In this entry_function and exit_function is written by me.So after executing module_exit execution will start from my function where I have to specify the major number and name of our driver,capacity to handle maximum number of device at a time and maximun memory of the driver. I am firstly allocating major number to my driver which is basically a highest possible integer value between 0 to 255 by which our driver will be known in the kernel like other device drivers as stored in /proc/devices file.We can select major number for our driver from prevoiusly mentioned path but generally we privilege kernel to select major number because kernel will allocate it dynamically.This can be done with the register_chrdev_region() function call defined in fs.h kernel library.This will give the result of 32 bit(12 + 20 bit) at the address as give in first argument of call.Now later on i have used that the first 12 bit i.e major number but i specify my own minor number generally 0 to upward in MKDEV() macro defined in kdev_t.h.Now used the cdev_init() and cdev_add() to initialize and add the cdev structure for our device which will contains the device specifications.Now i initialize the sculldev structure(user defined structure that contain all information of the driver) to add the maximum memory of device and the partition of that memory like size of one quantum etc.
Now I have open,write,read,lseek and close file till now.So i have mapped these system calls in struct file_operations structure with my respective open,write,read,lseek and close functions according to prototype defined in <fs.h> kernel header file that will now handles the application calls instead of drivers of the OS.
But Before doing anything we have to map our allocated memory with the device memory this is done in the open function of driver with
container_of(ptr,type,member) in which first argument is pointer to i_cdev member of struct inode,2nd argument is user defined structure which contains pointer to struct cdev and third argument is pointer to struct cdev.Actually struct cdev is actual representation of the device.Now return of container_of will be starting address of mapped memory that we will use to read and write on device and i store this address in the private_data of the struct file structure defined in fs.h library.
After doing this now i have made my read,write and lseek function compatible with the almost all type of requests from application.In this write function will store the written data in own quantum  when write request comes and give back that data according to the read request of application.I have also handled the single multi threaded application.

Now to test this driver firstly compile and insert our module in running kernel dynamically.This is done with command insmod <lkm.ko> on shell here lkm is my name of c file of driver.Compilation of the file should be by Makefile. And to make communication possible between application application and device driver,we require node in Virtual File System(VFS). Node is created by the commend “mknod node_name c major no. minor no.”,here c is to specify that is making for character driver.
After testing we should have to remove the module from kernel with command “rmmod” like rmmod lkm to free the allocated major number.
That was all i have done with character driver.

THANK YOU!!!