TWI438685B - Communication device and firmware patching method thereof - Google Patents

Description

Communication device and firmware patch method thereof

The invention relates to computer technology, in particular to a communication device and a firmware patching method thereof.

Routers, Ethernet switches, personal digital assistants (PDAs), or mobile phones, etc. The main execution programs such as boot programs and hardware configuration settings It is included in its firmware, and its function and efficiency affect the overall performance of the device. Therefore, software engineering has made considerable efforts in the development and debugging of firmware.

Software engineers often continue to modify firmware for a period of time after a product is released. This modification typically includes improvements in execution efficiency, debugging of code, addition of new features, and changes made to customer needs. Each time a new version of the firmware is released, it takes a time-consuming verification process and delays the programmer's reaction to the firmware issue. In addition, after downloading and installing the new firmware, the communication device reboots to boot the new firmware, but avoid restarting the Ethernet switch in an enterprise environment.

Embodiments of the present invention provide a communication device including a memory, a communication unit, and a processor. The above memory stores the communication device as a software program execution tube Physical service. The above software program includes a complex coupled service agent (TCSA). Each of the plurality of closely coupled service agents is a thread of the management service, and the management service further includes a thread called a system initialization manager for managing the complex close-coupled service agent. initialization. The communication unit is configured to communicate with an external device, and receive a loosely coupled service agent (LCSA) from the external device to replace one of the first agents of the plurality of closely coupled service agents, wherein the foregoing The coupling service agent provides a second function to replace the first function of the first agent described above. When the processor performs the above-mentioned decoupling service agent, the above-mentioned decoupling service agent is used as a software program to replace the first agent, disabling the first agent, and combining the data objects of the first agent to The above-mentioned sparse coupling service agent.

Another embodiment of the present invention provides a firmware patching method for a communication device, which is implemented in a communication device. The communication device includes a memory, a communication unit, and a processor. The above communication device firmware patch method includes the following steps.

The management device that stores the above communication device as a software program serves the above memory. The software program includes a complex crypto-coupling service agent, and each of the complex crypto-coupled service agents acts as a thread of the management service. The above management service also includes a thread called a system initialization manager for managing the initialization of the complex close-coupled service agent. The communication unit is configured to communicatively connect an external device, and receive a decoupling service agent from the external device to replace the first agent of the plurality of close-coupled service agents, wherein the decoupled service agent provides a second function to replace The first function of the first agent described above. When the above processor executes the above-mentioned decoupled service agent, the above-mentioned sparse coupling service generation As a software program, the processor is used to replace the first agent, and the first agent is disabled, and the data object of the first agent is combined with the above-mentioned sparse coupling service agent.

100‧‧‧Communication device

151‧‧‧ processor

152‧‧‧ main memory

153‧‧‧ Non-volatile memory

154‧‧‧Many storage devices

156‧‧‧Communication unit

158‧‧‧Power supply

159‧‧‧Crystal Oscillator

160‧‧‧Input and output devices

164‧‧‧埠

165‧‧‧ Controller

200‧‧‧Management Services (MLS)

210‧‧‧System Initialization Manager (SIM)

220a, 220b‧‧‧ Examples of data objects

2201‧‧‧Access category

2202‧‧‧Service agent capabilities

2203‧‧‧Initialization of dependency list

2206‧‧‧Name

2208‧‧‧Execution of dependency list

2209‧‧‧Service Agent Status

2210‧‧‧Service Agent Category

230‧‧‧Database

2301‧‧‧SIM data items

240a, 240b‧‧‧ Examples of data objects

2401‧‧‧Access category

2402‧‧‧回回函

2403‧‧‧Service Agent ID

2406‧‧‧Name

Version 2407‧‧‧

300‧‧‧External devices

50‧‧‧Timer

60‧‧‧Timer

A ₁ -A _n ,A _i ,A _j ,A _k ,A _m ,A _n ‧‧‧Double Coupled Service Agent (TCSA)

B‧‧‧Sparse Coupled Service Agent (LCSA)

1 is a block diagram showing the structure of a client device; FIG. 2 is a schematic diagram showing an embodiment of a management service; FIG. 3 is a diagram showing a state and state switching of a service agent; FIG. 4 is a schematic diagram showing a data object of a service agent; Schematic diagram of the data item of the system initialization manager; FIG. 6 shows a flow chart of the operation of the client device before receiving the patch data; FIG. 7 shows a flow chart of the operation of the client device after receiving the patch data; FIG. Schematic diagram of the data object of the agent; Figure 9 shows the initialization flow chart of the client device after receiving the patch data.

Referring to FIG. 1, the communication device 100 disclosed in the present invention may include a customer premises equipment (CPE), such as an Ethernet switch, a router, a modem, for example, : cable modem or very high-bit rate digital subscriber line (VDSL) modem. The client device 100 can be implemented as a single device or integrated into various electronic devices, such as a set top box or a personal computer.

1.1 Example of communication device

Referring to FIG. 1, the processor 151 is a central processing unit of the communication device 100, and may be composed of an integrated circuit (IC) for processing data and executing a computer program. The component connection mode of the communication device 100 is as shown in FIG. 1, and may be constituted by a serial or parallel bus bar or a wireless communication channel. The wireless communication unit 156 establishes a communication channel for the communication device 100 to connect to the Internet through the communication channel. In addition, the wireless communication unit 156 can establish a wireless communication channel, such as a mobile device, such as a computer or mobile device (such as a mobile phone, a remote controller, a laptop), to connect to the communication device 100 and exchange data through the wireless communication channel. The communication unit 156 may include an antenna, a base band, and a radio frequency (RF) chip set for performing wireless local area network (wireless LAN) communication, infrared communication, and/or a honeycomb. Communication system communication, such as Wideband Code Division Multiple Access (W-CDMA) and High Speed Downlink Packet Access (HSDPA). Through the wireless communication channel established above, the communication device 100 can serve as an access point of the wireless local area network, so that the mobile device can connect to the Internet via the access point.

The processor 151 may be composed of a single packaged IC or a plurality of packaged ICs having the same function or different functions. For example, the processor 151 may only include a central processing unit (CPU), or a CPU, a digital signal processor (DSP), and a communication controller (for example, the communication unit 156). Control the combination of wafers. The above-described communication controller may comprise cellular communication system communication, infrared, Bluetooth (Bluetooth ^TM) or wireless LAN communication control apparatus. The communication controller is used to control communication of components in the communication device 100 or communication between the communication device 100 and an external device.

The power supply 158 supplies power to each component in the communication device 100. The quartz oscillator 159 provides a clock signal to the processor 151 and other components in the communication device 100. The timers 50 and 60 may be constructed by circuitry, computer programs, or a combination thereof for timing a fixed length of time. A timer 50 or 60 expiration generates a signal to inform the end of the timed period. The input/output device 160 includes a control button, an alphanumeric keyboard, a touch panel, a touch screen, and a plurality of light emitting diodes (LEDs). The controller 165 detects and controls the operation and operation of the input/output device 160, and transmits the detected operation to the processor 151. The processor 151 can control the input/output device 160 through the controller 165. The 埠164 can be connected to a variety of computerized interfaces, such as an external computer device or peripheral device. The 埠164 may be an entity conforming to the standards of a universal serial bus (USB) or the Institute of Electrical and Electronics Engineers (IEEE) 1394, and the Electronic Industries Association (EIA). The physical connection port 埠, Serial ATA (Required Standard-232, RS-232) and/or Recommendation No. 11 (RS-11) Referred to as SATA) and / or High Definition Multimedia Interface (HDMI).

The nonvolatile memory 153 stores a firmware program including the operating system 190 and the application executed by the processor 151. The processor 151 can load the firmware program from the non-volatile memory 153 to the main memory 152 and execute it in the main memory 152 in the form of a software process. The above processor 151 The data is stored in the mass storage device 154. The main memory 152 may include a random access memory (RAM), such as, for example, a static random access memory (SRAM) or a dynamic random access memory (Dynamic RAM). DRAM). The non-volatile memory 153 may be an Electronically Erasable Programmable Read-Only Memory (EEPROM) or a flash memory, such as a reverse (NOR) flash memory. Or reverse (NAND) flash memory.

When the processor 151 completes the initialization of the operating system 190, the operating system 190 initializes and starts the first application of the application as a software program, called a management layer services (MLS) 200. The communication device 100 can obtain the patch data of the MLS 200 from the wireless communication signal, for example, through the antenna, the tuner, and the demodulator. Alternatively, the communication device 100 can obtain the patch data of the MLS 200 from the information network, for example, from the Internet through the network interface. The patch data includes a loosely coupled service agent (LCSA) for replacing the tightly coupled service agent (TCSA) of the communication device 100.

2. Patch method implementation

The above-described processor 151 in the above communication device 100 executes the above-described MLS 200 as a software program. Referring to FIG. 2, the MLS 200 includes a system initialization manager (SIM) 210 and a tightly coupled service agent (TCSA) A ₁ -A _n , where n is an integer greater than one. When TCSA A ₁ -A _n, wherein each of TCSA 151 executed by the processor, the communications device 100 provides a guide function, such as Network Time Protocol (network time protocol, NTP), (bridge) bridge, firewall (Firewall ), or dynamic host configuration protocol (DHCP). When the processor 151 executes the MLS 200 software program, each of the above SIM 210 and TCSA A ₁ -A _n is executed in the form of a thread. As shown in FIG. 3, the above-described TCSA A ₁ -A _n, wherein each of the plurality having a TCSA SIM 210 may be managed by the state, comprising initially registered, wait, set their own, is set to start is performed, and end disabling. In Figure 3, the state of each service agent is represented by a node whose state switching is represented by a line connecting the two nodes. The state and state switching of the loosely coupled service agent (LCSA) is the same as the TCSA state and state switching shown in FIG. The LCSA is a service agent program carried in the patch material and is executed by the above processor 151 in the form of a software program. SIM 210 controls and manages the above-described initialization and execution TCSA A ₁ -A _n and the LCSA. SIM 210 using the above-described TCSA A ₁ -A _n and LCSA wherein each service agent program call (procedure call) to switch the service agent of the complex to a state wherein the above-described state. A service agent, such as TCSA or LCSA, registers relevant information in the initial state to the SIM 210 described above, and when the registration is completed, switches from the initial state to the registered state. The service agent notifies the SIM 210 of the dependency relationship associated with the service agent, and switches from the registered state to the waiting state. The above-mentioned dependency relationship includes the initialization dependency relationship and the execution dependency relationship of the above service agent. In the above-described controlling SIM 210 initialization job dependency relationships of the complex TCSA A ₁ -A _n and according to the above initialization LCSA. For example, when the SIM 210 initializes a specific service agent that is in a waiting state, the specific service agent is driven to perform self-configuration, and enters a self-setting state from the waiting state. When the self-setting is completed, the specific service agent enters the set state from the self-setting state. The SIM 210 can drive all the TCSAs and LCSAs to which the specific service agent is attached to enter the set state before driving the specific service agent to set itself. When the processor 151 executes a service agent-related complex driver, the service agent switches to the above-described execution state. The SIM 210 drives the specific service agent to enter the startup state after driving all the TCSAs and LCSAs to which the specific service agent is attached to enter the execution state. The processor 151 executes the particular service agent in an active state to enter the execution state. When the processor 151 stops executing a service agent-related complex driver, the service agent switches to the disabled state, and when the related information of the service agent is released and is no longer associated with the service agent. The above service agent enters the above end state.

2.1 Initialize the dependency database and execute the dependency database

The device 100 uses the SetParameterValues function and the application programming interface (API) defined in the technical report 069 (Technical Report 069, TR069) to set the value in the database 230, and informs the multiple TCSA and LCSA about the above data. The event in the library 230 changes the value.

The main memory 152 stores the MLS 200 and its data items and profiles. The above information items include an initialization dependency relational database for storing the initialization of the complex dependencies TCSA A ₁ -A _n and the LCSA, and perform execution of the complex for storing TCSA A ₁ -A _n and LCSA dependency relationship dependencies database. SIM 210 based on the above-described initialization dependency relationships above TCSA A ₁ -A _n is initialized, and to start execution of the job dependency relationships above TCSA A ₁ -A _n according to the execution.

4 shows examples 240a and 240b of the data items in the object database 230 described above. Each of the above examples 240a and 240b is associated with a service agent and includes the following data items: access categories, callback functions, agent identification (ID), name And version. For example, the above examples TCSA A _i associated with the categories 240a include accessing 2401, the callback function 2402, the service agent ID 2403, name 2406 and 2407 editions. The variable i is an integer and 1≦i≦n. The above access category 2401 data object identifies its associated service agent TCSA A _i as TCSA or LCSA. Callback function 2402 described above include links to its associated service agent TCSA A _i with reference to the callback function address. The service agent ID 2403, name 2406, and version 2407 respectively include the ID, name, and version of the service agent TCSA A _i .

FIG. 5 shows the data item 2301 of the SIM 210 described above in the above-described database 230. The data item 2301 of the SIM 210 described above contains data items for controlling the service agent, such as instances 220a and 220b. Each data object used to control the service agent includes an access category, a service broker capability, an initialization dependency list, a name, a list of execution dependencies, a service broker state, and a service broker category. For example, related to the service agent TCSA A _i data object instance 220a includes access Category 2201, 2202 service agent capabilities, initialization dependency list 2203, name 2206, execution dependency list 2208, 2209 service agent status And service agent category 2210. The SIM 210 records the capability of the service agent TCSA A _i on the object 2202, its initialization dependency list, and the execution dependency list on the objects 2203 and 2208. The status of the service agent TCSA A _i is in the object 2209. The initialization dependency list and the execution dependency list respectively represent the initialization dependency relationship and the execution dependency relationship of the service agent TCSA A _i . The initialization dependency list and the execution dependency list respectively include a plurality of service agents attached to the service agent TCSA _i at the time of initialization and execution. The service agent included in the above list of initialization and execution dependencies is referred to as the base service agent of the service agent TCSA A _i described above. In FIG. 5, the above-described initialization dependency list includes only the base service agent A _j , and the above-described execution dependency list includes the base service agents A _k , A _m , and A _n .

2.2 Original operational process

The MLS 200 described above instructs the processor 151 to perform the following operations:

Referring to FIG. 6, the SIM 210 so that the TCSA A ₁ -A TCSA _n wherein each switch from the initial state to the next state (step S100). Each of the TCSAs A ₁ -A _n described above is initially in an initial state (step S102), and registration with the above-described SIM 210 is started (step S104). When a TCSA (e.g., TCSA A _i ) completes registration, the SIM 210 controls the TCSA to switch from the initial state to the registered state (step S106). Above TCSA A ₁ -A _n wherein each register its service agent comprising TCSA capability registration operation of the above-described SIM 210. Referring to FIG. 5, the service agent capability of the TCSA A _i is stored in the data item 230 of the above-described SIM 210. The following description takes the above TCSA A _i as an example, and it is to be understood that the steps therein can be applied to each of the above TCSAs A ₁ -A _n .

The registered TCSA A _i notifies the SIM 210 of the dependency relationship with respect to the above TCSA A _i (step S108). The dependency relationship of the above TCSA A _i includes an initialization dependency relationship and an execution dependency relationship. The registered TCSA A _{i is} associated with the material in the database 230 (step S110) and is switched from the registered state to the waiting state (step S112). The associated job in the above step S110 is referred to as data binding. The data binding in the above step S110 includes storing the ID of the TCSA A _i in the service agent ID data object 2403. The SIM 210 drives the initialization operation of the TCSA A _i according to the initialization dependency relationship described above, and executes the TCSA A _i according to the above-described execution dependency relationship (step S114). For example, the initialization dependency relationship in the initialization dependency database includes the first relationship in the database 230 to indicate that the TCSA A _{i is} attached to the TCSA A _j , in other words, the initialization of the TCSA A _i follows After the initialization of the above TCSA A _j . The above variable j is an integer, and 1≦j≦n, and j≠i. In the above step S114, the SIM 210 sequentially drives the initialization of the TCSA A _j and the TCSA A _i . In the above-described initialization process TCSA A _j in the SIM 210 controls the self configuration TCSA A _j, and switches from the wait state to the self-setting state. After the initialization of the TCSA A _j is completed, the SIM 210 drives (step S116) the initialization of the TCSA A _i , wherein the SIM 210 controls the TCSA A _{i to} perform self-setting, and switches from the waiting state to the self-setting state ( Step S118). Above TCSA A ₁ -A _n wherein each TCSA initialization, for example, setting the driver may comprise one or more TCSA function. The above TCSA A _i performs state switching according to FIG.

2.3 Patch operation process during program execution

The communication unit 156 communicates with the external device 300, and receives the LCSA B from the external device 300 to replace the TCSA A _i described above. The LCSA B is referred to as a patch of the above TCSA A _i to provide a second function to replace the first function of the TCSA A _i described above. For example, the first function and the second function may include, for example, an NTP, a bridge, a firewall, or a DHCP function.

The processor 151 executes the above-described in the form of a program instead of the above-described LCSA B to TCSA A _i, comprising the above-described disabling TCSA A _i in the above substituents means, and data object associated with the above-described TCSA A _i to the LCSA B. As shown in Figure 3, the state and state switching of the LCSA is like TCSA. Thus, the apparatus 100 described above can receive one or more LCSAs in place of one or more TCSAs.

Referring to Fig. 7, TCSA A _{i is} initially in an initial state (step S200). The SIM 210 switches the LCSA B from the initial state to the next state (step S202). The LCSA B described above starts to register with the SIM 210 described above (step S204). The above LCSA B registration operation in the above SIM 210 includes the registration of its service agent capabilities. When the LCSA B completes registration, the SIM 210 controls the LCSA B to switch from the initial state to the registered state (step S206).

The registered LCSA B notifies the dependency relationship of the above SIM 210 regarding the LCSA B described above (step S208). The dependency relationship of the LCSA B described above includes an initialization dependency relationship and an execution dependency relationship. The LCSA B and the SIM 210 described above instruct the processor 151 to increase the dependency relationship of the LCSA B to the database 230. The LCSA B switches from the registered state to the waiting state (step S212). SIM 210 based on the above-described initialization dependency relationships driving the TCSA A ₁ -A _n and initialization operations LCSA B, and according to the execution dependency relationships to perform the above TCSA A ₁ -A _n and LCSA B (step S214). For example, the initialization dependency relationship of the LCSA B described above includes a second relationship in the database 230 to indicate that the LCSA B is attached to the TCSA A _j . In other words, in step S214, the initialization of the LCSA B described above follows the initialization of the aforementioned TCSA A _j . In the above-described initialization process TCSA A _j in the SIM 210 controls the self configuration TCSA A _j, and switches from the wait state to the self-setting state. After the initialization of the TCSA A _j is completed, the SIM 210 drives the initialization of the LCSA B, wherein the SIM 210 controls the LCSA B to perform self-setting, and switches from the waiting state to the self-setting state (step S216). The initialization of the LCSA B described above may include, for example, a driver that sets one or more functions of the LCSA B described above.

The self-setting operation of the above LCSA B includes driving the above TCSA A _{i to} disable. For example, the LCSA B requests the TCSA A _{i to} switch from the above execution state to the disabled state (step S218). The above TCSA A _i notifies the above SIM 210 that its state has been switched to the disabled state (step S220). When the SIM 210 responds to the above notification, it drives all the TCSAs and LCSAs attached to the TCSA A _i to enter a waiting state (step S222). The SIM 210 drives the TCSA A _{i to} switch to the end state (step S224).

The LCSA B associates the data object of the TCSA A _i in the database 230 to complete data binding (step S226) and switches from the self-setting state to the waiting state (step S228). As shown in FIG. 8, the data binding in the above step S226 includes storing the ID of the LCSA B in the service agent ID data object 2403. After the step S226 is completed, the SIM 210 drives the initialization of the LCSA B (step S230). In the initialization process of the LCSA B, the SIM 210 controls the LCSA B to perform self-setting (step S230), and switches from the waiting state. The self-set state is reached (step S232). The initialization of the LCSA B described above may include, for example, a driver that sets one or more functions of the LCSA B described above.

In the above step S208, the LCSA B may add an execution dependency relationship in the database 230 to indicate that the execution of the LCSA B follows the one or more TCSA execution jobs. The SIM 210 drives the LCSA B to be executed after the one or more TCSAs have been executed according to the newly added execution dependency relationship.

2.4 Replacement of jobs during system initialization

Referring to Fig. 9, the SIM 210 switches the TCSA A _i from the initial state to the next state (step S300). The above TCSA A _i starts to be registered with the above SIM 210 (step S304). When the TCSA A _i completes registration, the SIM 210 controls the TCSA A _{i to} switch from the initial state to the registered state (step S306).

The above registered TCSA A _i establishes and notifies the dependency relationship with respect to the above TCSA A _i to the SIM 210 (step S308). The dependency relationship of the above TCSA A _i includes an initialization dependency relationship and an execution dependency relationship. The registered TCSA A _{i is} associated with the data item in the above-described database 230 (step S310) and is switched from the registered state to the waiting state (step S312).

The SIM 210 switches the LCSA B from the initial state to the next state (step S313). The LCSA B described above starts to register with the SIM 210 described above (step S314). When the LCSA B completes registration, the SIM 210 controls the LCSA B to switch from the initial state to the registered state (step S316).

The above-mentioned registered LCSA B is established and informs about the dependency relationship of the LCSA B described above to the SIM 210 described above (step S318). The dependency relationship of the LCSA B described above includes an initialization dependency relationship and an execution dependency relationship. The initialization dependency relationship of the LCSA B indicates that the initialization of the LCSA B takes precedence over all the TCSAs. Step S318 is referred to as a first dependency relationship establishing step. The registered LCSA B described above is switched from the above registered state to the above waiting state (step S322). SIM 210 based on the above-described initialization of the above-described dependency relationships LCSA B driver initialization operation described above TCSA A ₁ -A _n and LCSA B (step S324). In the above step S324, the SIM 210 drives the initialization of the LCSA B, and takes precedence over all the TCSAs including the TCSA A _i . In the initialization of the registered LCSA B, the SIM 210 controls the LCSA B to perform self-setting, and switches from the waiting state to the self-setting state (step S326).

The self-setting operation of the above LCSA B includes driving the above TCSA A _{i to} disable. For example, the LCSA B requests the TCSA A _{i to} switch from the above execution state to the disabled state (step S332). The above TCSA A _i notifies the above SIM 210 that its state has been switched to the disabled state. The SIM 210 drives the TCSA A _{i to} switch to the end state described above.

The LCSA B is associated with the data object of the TCSA A _i in the database 230 to complete data binding (step S334), notifying the new dependency relationship of the LCSA B to the SIM 210 (step S336), and setting the self-setting from the above. The state is switched to the above waiting state (step S338). The new dependency relationship of the LCSA B described above is used to replace the dependency relationship in the first dependency relationship establishing step described above. One of the dependency relationships in the new dependency relationship of the LCSA B indicates that the initialization of the LCSA B described above follows the initialization of the TCSA A _j described above. In step S340, the above-described driving the SIM 210 initialization TCSA A _j priority initialization of LCSA B above. After the completion of the above step S340, the SIM 210 drives the initialization of the LCSA B, wherein the SIM 210 controls the LCSA B to perform self-setting (step S342), and switches from the waiting state to the self-setting state. The initialization of the LCSA B described above may include, for example, a driver that sets one or more functions of the LCSA B described above.

3. Conclusion

In summary, the above apparatus 100 executes the above-described MLS 200 in a separate software program form, and executes a plurality of TCSAs in the form of threads as threads in the above-described software program, and receives the LCSA to replace the erroneous TCSA. The above device 100 executes the LCSA described above in another software program. The SIM 210 described above standardizes the management of the states of the plurality of TCSAs and LCSAs.

A _i ‧‧‧Double Coupled Service Agent (TCSA)

B‧‧‧Sparse Coupled Service Agent (LCSA)

210‧‧‧System Initialization Manager (SIM)

230‧‧‧Database

S220-S232‧‧‧ firmware patch method steps

Claims (10)

A communication device comprising: a memory storing the communication device as a management service executed by a software program, the software program comprising a tightly coupled service agent (TCSA), the complex crypto-coupled service agent Each of the close-coupled service agents acts as a thread of the management service, and the management service further includes a thread called a system initialization manager for managing initialization of the complex-closed service broker; a communication unit, Relating to an external device by communication, and receiving a loosely coupled service agent (LCSA) from the external device to replace one of the first agents of the complex close-coupled service agent, wherein the above-mentioned sparsely coupled service agent Providing a second function to replace the first function of the first agent; a processor, when performing the above-mentioned decoupling service agent, the above-mentioned decoupled service agent is used as a software program to replace the first agent, and is disabled The first agent, combined with the information of the first agent Object to the above-mentioned sparse coupling service agent. The communication device of claim 1, wherein the memory comprises an initialization dependent database for storing an initialization dependency relationship of the complex close-coupled service proxy, and the system initialization manager according to the initialization dependency relationship Initialize the above complex crypto-coupling service agent. The communication device of claim 2, wherein the initialization dependency relationship comprises a first relationship, wherein the first relationship is used to indicate that initialization of the first agent follows one of the plurality of complex coupled service agents. After the initialization of the two agents, the above-mentioned sparse coupling service agent instructs the processor to add a second dependency relationship to the initialization dependency relationship, and the second dependency relationship indicates initialization of the sparse coupling service agent. After the initialization of the second agent, the system initialization manager instructs the processor to initiate initialization of the sparse coupling service agent after initialization of the second agent according to the second dependency relationship; and the decoupling service The agent disables the first agent described above. The communication device of claim 3, wherein: during the initialization of the communication device, the decoupling service agent increases a third dependency relationship to the initialization dependency relationship, and the third dependency relationship indicates the sparse coupling service agent The initialization of the device precedes the initialization of the complex crypto-coupling service agent; during the initialization of the splicing service agent according to the third dependency relationship, the splicing service agent disables the first agent, and The second dependency relationship is added to the initialization dependency relationship to replace the third dependency relationship. The communication device of claim 3, wherein the first agent has a complex state, and the system initialization manager uses the program call of the first agent to switch the first agent to the plurality of states. One of the states. The communication device of claim 5, wherein the memory comprises an execution dependent database for storing an execution dependency relationship of the complex close-coupled service agent, and the system initialization manager according to the execution dependency relationship The execution of the above complex close-coupled service agent is started. The communication device of claim 6, wherein the execution dependency relationship includes a fourth dependency relationship, wherein the fourth dependency relationship is used to indicate that the execution operation of the first agent follows the complex crypto-coupling service agent. After the execution of the third agent, after the communication device receives the decoupling service agent, the processor registers the decoupling service agent in the system initialization manager; the decoupling service agent increases the fifth Dependent on the execution dependency relationship, the fifth dependency relationship indicating that the execution operation of the sparsely coupled service agent follows the third agent After the execution of the job, and the system initialization manager starts the execution of the above-described decoupled service agent after the execution of the third agent according to the fifth dependency relationship. A communication device firmware patching method is implemented in a communication device, the communication device comprising a memory, a communication unit and a processor, comprising: storing the communication device as a software program to perform management services on the memory, The software program includes a complex crypto-coupling service agent, each of the complex crypto-coupling service agents acting as a thread of the management service, and the management service further includes a thread called a system initialization manager. And the communication unit is configured to communicate with an external device, and receive a decoupled service agent from the external device to replace the first agent of the complex close-coupled service agent, Wherein the above-mentioned decoupling service agent provides a second function to replace the first function of the first agent; when the processor executes the above-mentioned decoupling service agent, the above-mentioned decoupled service agent is used as a software program to replace the above An agent that disables the first agent above, In conjunction with the first agent of the above-mentioned data objects to loosely coupled service agent. The communication device firmware patch method of claim 8, wherein the memory comprises an initialization dependent database for storing an initialization dependency relationship of the complex close-coupled service proxy, and the system initialization manager according to the above The dependency relationship is initialized to initialize the complex crypto-coupled service agent described above. The communication device firmware patch method of claim 9, wherein the initialization dependency relationship comprises a first relationship, wherein the first relationship is used to indicate that initialization of the first agent follows the complex crypto-coupled service agent After the initialization of the second agent, the sparsely coupled service agent instructs the processor to add a second dependency relationship to the initialization dependency relationship, and the second dependency relationship indicates initialization of the sparsely coupled service agent. After the initialization of the second agent, the system initialization manager instructs the processor to initiate initialization of the sparse coupling service agent after initialization of the second agent according to the second dependency relationship; and the decoupling service The agent disables the first agent described above.